diff --git a/include/scratchcpp/costume.h b/include/scratchcpp/costume.h
index e81d26ce..1436a139 100644
--- a/include/scratchcpp/costume.h
+++ b/include/scratchcpp/costume.h
@@ -9,6 +9,7 @@
 namespace libscratchcpp
 {
 
+class Broadcast;
 class CostumePrivate;
 
 /*! \brief The Costume class represents a Scratch costume. */
@@ -27,6 +28,8 @@ class LIBSCRATCHCPP_EXPORT Costume : public Asset
         int rotationCenterY() const;
         void setRotationCenterY(int newRotationCenterY);
 
+        Broadcast *broadcast();
+
     private:
         spimpl::unique_impl_ptr<CostumePrivate> impl;
 };
diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 46e9fc7d..b497f1db 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -65,6 +65,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Starts the script of the broadcast with the given index. */
         virtual void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) = 0;
 
+        /*! Starts the script of the given broadcast. */
+        virtual void broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait = false) = 0;
+
         /*! Stops the given script. */
         virtual void stopScript(VirtualMachine *vm) = 0;
 
@@ -122,6 +125,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns true if there are any running script of the broadcast with the given index. */
         virtual bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) = 0;
 
+        /*! Returns true if there are any running script of the given broadcast. */
+        virtual bool broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript) = 0;
+
         /*!
          * Call this from a block implementation to force a "screen refresh".
          * \note This has no effect in "run without screen refresh" custom blocks.
@@ -199,7 +205,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual int findBroadcastById(const std::string &broadcastId) const = 0;
 
         /*! Registers the broadcast script. */
-        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::shared_ptr<Broadcast> broadcast) = 0;
+        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) = 0;
 
         /* Registers the given "when I start as clone" script. */
         virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index f06192f2..1961ef13 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -6,6 +6,8 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/stage.h>
+#include <scratchcpp/costume.h>
 
 #include "eventblocks.h"
 
@@ -23,12 +25,14 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "event_broadcast", &compileBroadcast);
     engine->addCompileFunction(this, "event_broadcastandwait", &compileBroadcastAndWait);
     engine->addCompileFunction(this, "event_whenbroadcastreceived", &compileWhenBroadcastReceived);
+    engine->addCompileFunction(this, "event_whenbackdropswitchesto", &compileWhenBackdropSwitchesTo);
 
     // Inputs
     engine->addInput(this, "BROADCAST_INPUT", BROADCAST_INPUT);
 
     // Fields
     engine->addField(this, "BROADCAST_OPTION", BROADCAST_OPTION);
+    engine->addField(this, "BACKDROP", BACKDROP);
 }
 
 void EventBlocks::compileBroadcast(Compiler *compiler)
@@ -66,7 +70,18 @@ void EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
 {
     auto broadcast = std::static_pointer_cast<Broadcast>(compiler->field(BROADCAST_OPTION)->valuePtr());
 
-    compiler->engine()->addBroadcastScript(compiler->block(), broadcast);
+    compiler->engine()->addBroadcastScript(compiler->block(), 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());
+    }
 }
 
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
index f3b47b89..ca310d51 100644
--- a/src/blocks/eventblocks.h
+++ b/src/blocks/eventblocks.h
@@ -21,7 +21,8 @@ class EventBlocks : public IBlockSection
 
         enum Fields
         {
-            BROADCAST_OPTION
+            BROADCAST_OPTION,
+            BACKDROP
         };
 
         std::string name() const override;
@@ -31,6 +32,7 @@ class EventBlocks : public IBlockSection
         static void compileBroadcast(Compiler *compiler);
         static void compileBroadcastAndWait(Compiler *compiler);
         static void compileWhenBroadcastReceived(Compiler *compiler);
+        static void compileWhenBackdropSwitchesTo(Compiler *compiler);
 
         static unsigned int broadcast(VirtualMachine *vm);
         static unsigned int broadcastByIndex(VirtualMachine *vm);
diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index 151036dc..754c3272 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -31,6 +31,7 @@ void LooksBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "looks_switchcostumeto", &compileSwitchCostumeTo);
     engine->addCompileFunction(this, "looks_nextcostume", &compileNextCostume);
     engine->addCompileFunction(this, "looks_switchbackdropto", &compileSwitchBackdropTo);
+    engine->addCompileFunction(this, "looks_switchbackdroptoandwait", &compileSwitchBackdropToAndWait);
     engine->addCompileFunction(this, "looks_nextbackdrop", &compileNextBackdrop);
     engine->addCompileFunction(this, "looks_costumenumbername", &compileCostumeNumberName);
     engine->addCompileFunction(this, "looks_backdropnumbername", &compileBackdropNumberName);
@@ -157,6 +158,47 @@ void LooksBlocks::compileSwitchBackdropTo(Compiler *compiler)
     }
 }
 
+void LooksBlocks::compileSwitchBackdropToAndWait(Compiler *compiler)
+{
+    Stage *stage = compiler->engine()->stage();
+
+    if (!stage)
+        return;
+
+    Input *input = compiler->input(BACKDROP);
+
+    if (input->type() != Input::Type::ObscuredShadow) {
+        assert(input->pointsToDropdownMenu());
+        std::string value = input->selectedMenuItem();
+        int index = stage->findCostume(value);
+
+        if (index == -1) {
+            if (value == "next backdrop")
+                compiler->addFunctionCall(&nextBackdropAndWait);
+            else if (value == "previous backdrop")
+                compiler->addFunctionCall(&previousBackdropAndWait);
+            else if (value == "random backdrop")
+                compiler->addFunctionCall(&randomBackdropAndWait);
+            else {
+                Value v(value);
+
+                if (v.type() == Value::Type::Integer) {
+                    compiler->addConstValue(v.toLong() - 1);
+                    compiler->addFunctionCall(&switchBackdropToByIndexAndWait);
+                }
+            }
+        } else {
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&switchBackdropToByIndexAndWait);
+        }
+    } else {
+        compiler->addInput(input);
+        compiler->addFunctionCall(&switchBackdropToAndWait);
+    }
+
+    compiler->addFunctionCall(&checkBackdropScripts);
+}
+
 void LooksBlocks::compileNextBackdrop(Compiler *compiler)
 {
     compiler->addFunctionCall(&nextBackdrop);
@@ -308,20 +350,26 @@ unsigned int LooksBlocks::previousCostume(VirtualMachine *vm)
     return 0;
 }
 
-unsigned int LooksBlocks::switchBackdropToByIndex(VirtualMachine *vm)
+void LooksBlocks::startBackdropScripts(VirtualMachine *vm, bool wait)
+{
+    if (Stage *stage = vm->engine()->stage()) {
+        if (stage->costumes().size() > 0)
+            vm->engine()->broadcastByPtr(stage->costumeAt(stage->currentCostume() - 1)->broadcast(), vm, wait);
+    }
+}
+
+void LooksBlocks::switchBackdropToByIndexImpl(VirtualMachine *vm)
 {
     if (Stage *stage = vm->engine()->stage())
         setCostumeByIndex(stage, vm->getInput(0, 1)->toLong());
-
-    return 1;
 }
 
-unsigned int LooksBlocks::switchBackdropTo(VirtualMachine *vm)
+void LooksBlocks::switchBackdropToImpl(VirtualMachine *vm)
 {
     Stage *stage = vm->engine()->stage();
 
     if (!stage)
-        return 1;
+        return;
 
     const Value *name = vm->getInput(0, 1);
     std::string nameStr = name->toString();
@@ -329,38 +377,32 @@ unsigned int LooksBlocks::switchBackdropTo(VirtualMachine *vm)
 
     if (index == -1) {
         if (nameStr == "next backdrop")
-            nextBackdrop(vm);
+            nextBackdropImpl(vm);
         else if (nameStr == "previous backdrop")
-            previousBackdrop(vm);
+            previousBackdropImpl(vm);
         else if (nameStr == "random backdrop") {
-            randomBackdrop(vm);
+            randomBackdropImpl(vm);
         } else {
             if (name->type() == Value::Type::Integer)
                 setCostumeByIndex(stage, name->toLong() - 1);
         }
     } else
         setCostumeByIndex(stage, index);
-
-    return 1;
 }
 
-unsigned int LooksBlocks::nextBackdrop(VirtualMachine *vm)
+void LooksBlocks::nextBackdropImpl(VirtualMachine *vm)
 {
     if (Stage *stage = vm->engine()->stage())
         setCostumeByIndex(stage, stage->currentCostume());
-
-    return 0;
 }
 
-unsigned int LooksBlocks::previousBackdrop(VirtualMachine *vm)
+void LooksBlocks::previousBackdropImpl(VirtualMachine *vm)
 {
     if (Stage *stage = vm->engine()->stage())
         setCostumeByIndex(stage, stage->currentCostume() - 2);
-
-    return 0;
 }
 
-unsigned int LooksBlocks::randomBackdrop(VirtualMachine *vm)
+void LooksBlocks::randomBackdropImpl(VirtualMachine *vm)
 {
     if (!rng)
         rng = RandomGenerator::instance().get();
@@ -371,6 +413,94 @@ unsigned int LooksBlocks::randomBackdrop(VirtualMachine *vm)
         if (count > 0)
             stage->setCurrentCostume(rng->randint(1, count));
     }
+}
+
+unsigned int LooksBlocks::switchBackdropToByIndex(VirtualMachine *vm)
+{
+    switchBackdropToByIndexImpl(vm);
+    startBackdropScripts(vm, false);
+
+    return 1;
+}
+
+unsigned int LooksBlocks::switchBackdropTo(VirtualMachine *vm)
+{
+    switchBackdropToImpl(vm);
+    startBackdropScripts(vm, false);
+
+    return 1;
+}
+
+unsigned int LooksBlocks::switchBackdropToByIndexAndWait(VirtualMachine *vm)
+{
+    switchBackdropToByIndexImpl(vm);
+    startBackdropScripts(vm, true);
+
+    return 1;
+}
+
+unsigned int LooksBlocks::switchBackdropToAndWait(VirtualMachine *vm)
+{
+    switchBackdropToImpl(vm);
+    startBackdropScripts(vm, true);
+
+    return 1;
+}
+
+unsigned int LooksBlocks::nextBackdrop(VirtualMachine *vm)
+{
+    nextBackdropImpl(vm);
+    startBackdropScripts(vm, false);
+
+    return 0;
+}
+
+unsigned int LooksBlocks::nextBackdropAndWait(VirtualMachine *vm)
+{
+    nextBackdropImpl(vm);
+    startBackdropScripts(vm, true);
+
+    return 0;
+}
+
+unsigned int LooksBlocks::previousBackdrop(VirtualMachine *vm)
+{
+    previousBackdropImpl(vm);
+    startBackdropScripts(vm, false);
+
+    return 0;
+}
+
+unsigned int LooksBlocks::previousBackdropAndWait(VirtualMachine *vm)
+{
+    previousBackdropImpl(vm);
+    startBackdropScripts(vm, true);
+
+    return 0;
+}
+
+unsigned int LooksBlocks::randomBackdrop(VirtualMachine *vm)
+{
+    randomBackdropImpl(vm);
+    startBackdropScripts(vm, false);
+
+    return 0;
+}
+
+unsigned int LooksBlocks::randomBackdropAndWait(VirtualMachine *vm)
+{
+    randomBackdropImpl(vm);
+    startBackdropScripts(vm, true);
+
+    return 0;
+}
+
+unsigned int LooksBlocks::checkBackdropScripts(VirtualMachine *vm)
+{
+    if (Stage *stage = vm->engine()->stage()) {
+        if ((stage->costumes().size() > 0) && vm->engine()->broadcastByPtrRunning(stage->costumeAt(stage->currentCostume() - 1)->broadcast(), vm))
+            vm->stop(true, true, true);
+    }
 
     return 0;
 }
diff --git a/src/blocks/looksblocks.h b/src/blocks/looksblocks.h
index 8f78453d..cefe7e9b 100644
--- a/src/blocks/looksblocks.h
+++ b/src/blocks/looksblocks.h
@@ -8,6 +8,8 @@ namespace libscratchcpp
 {
 
 class Target;
+class Stage;
+class Value;
 class IRandomGenerator;
 
 /*! \brief The LooksBlocks class contains the implementation of looks blocks. */
@@ -45,6 +47,7 @@ class LooksBlocks : public IBlockSection
         static void compileSwitchCostumeTo(Compiler *compiler);
         static void compileNextCostume(Compiler *compiler);
         static void compileSwitchBackdropTo(Compiler *compiler);
+        static void compileSwitchBackdropToAndWait(Compiler *compiler);
         static void compileNextBackdrop(Compiler *compiler);
         static void compileCostumeNumberName(Compiler *compiler);
         static void compileBackdropNumberName(Compiler *compiler);
@@ -61,11 +64,24 @@ class LooksBlocks : public IBlockSection
         static unsigned int nextCostume(VirtualMachine *vm);
         static unsigned int previousCostume(VirtualMachine *vm);
 
+        static void startBackdropScripts(VirtualMachine *vm, bool wait);
+        static void switchBackdropToByIndexImpl(VirtualMachine *vm);
+        static void switchBackdropToImpl(VirtualMachine *vm);
+        static void nextBackdropImpl(VirtualMachine *vm);
+        static void previousBackdropImpl(VirtualMachine *vm);
+        static void randomBackdropImpl(VirtualMachine *vm);
+
         static unsigned int switchBackdropToByIndex(VirtualMachine *vm);
         static unsigned int switchBackdropTo(VirtualMachine *vm);
+        static unsigned int switchBackdropToByIndexAndWait(VirtualMachine *vm);
+        static unsigned int switchBackdropToAndWait(VirtualMachine *vm);
         static unsigned int nextBackdrop(VirtualMachine *vm);
+        static unsigned int nextBackdropAndWait(VirtualMachine *vm);
         static unsigned int previousBackdrop(VirtualMachine *vm);
+        static unsigned int previousBackdropAndWait(VirtualMachine *vm);
         static unsigned int randomBackdrop(VirtualMachine *vm);
+        static unsigned int randomBackdropAndWait(VirtualMachine *vm);
+        static unsigned int checkBackdropScripts(VirtualMachine *vm);
 
         static unsigned int costumeNumber(VirtualMachine *vm);
         static unsigned int costumeName(VirtualMachine *vm);
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index e4190948..4fb00a68 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -13,6 +13,7 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
+#include <scratchcpp/costume.h>
 #include <cassert>
 #include <iostream>
 #include <thread>
@@ -207,10 +208,18 @@ void Engine::startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<T
 }
 
 void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait)
+{
+    if (index < 0 || index >= m_broadcasts.size())
+        return;
+
+    broadcastByPtr(m_broadcasts[index].get(), sourceScript, wait);
+}
+
+void Engine::broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait)
 {
     bool previousSkipFrame = m_skipFrame;
     skipFrame();
-    const std::vector<Script *> &scripts = m_broadcastMap[index];
+    const std::vector<Script *> &scripts = m_broadcastMap[broadcast];
 
     for (auto script : scripts) {
         std::vector<VirtualMachine *> runningBroadcastScripts;
@@ -229,7 +238,7 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
             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());
 
-            auto &scripts = m_runningBroadcastMap[index];
+            auto &scripts = m_runningBroadcastMap[broadcast];
 
             for (auto &pair : scripts) {
                 if (pair.second->script() == script)
@@ -264,7 +273,7 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
             if (it == runningBroadcastScripts.end()) {
                 auto vm = script->start(target);
                 m_runningScripts.push_back(vm);
-                m_runningBroadcastMap[index].push_back({ sourceScript, vm.get() });
+                m_runningBroadcastMap[broadcast].push_back({ sourceScript, vm.get() });
             }
         }
     }
@@ -411,7 +420,20 @@ void Engine::setStageHeight(unsigned int height)
 
 bool Engine::broadcastRunning(unsigned int index, VirtualMachine *sourceScript)
 {
-    const auto &scripts = m_runningBroadcastMap[index];
+    if (index < 0 || index >= m_broadcasts.size())
+        return false;
+
+    return broadcastByPtrRunning(m_broadcasts[index].get(), sourceScript);
+}
+
+bool Engine::broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript)
+{
+    auto it = m_runningBroadcastMap.find(broadcast);
+
+    if (it == m_runningBroadcastMap.cend())
+        return false;
+
+    const auto &scripts = it->second;
 
     for (const auto &pair : scripts) {
         if (pair.first == sourceScript)
@@ -567,19 +589,18 @@ int Engine::findBroadcastById(const std::string &broadcastId) const
     return -1;
 }
 
-void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::shared_ptr<Broadcast> broadcast)
+void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast)
 {
-    auto id = findBroadcast(broadcast->name());
-    if (m_broadcastMap.count(id) == 1) {
-        std::vector<Script *> &scripts = m_broadcastMap[id];
+    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[id] = { m_scripts[whenReceivedBlock].get() };
+        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[id] = {};
+        m_runningBroadcastMap[broadcast] = {};
     }
 }
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 438daea2..60dfd6aa 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -31,6 +31,7 @@ class Engine : public IEngine
         void stop() override;
         void startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<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 stopScript(VirtualMachine *vm) override;
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
         void initClone(libscratchcpp::Sprite *clone) override;
@@ -54,6 +55,7 @@ class Engine : public IEngine
         void setStageHeight(unsigned int height) override;
 
         bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) override;
+        bool broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript) override;
 
         void breakFrame() override;
         bool breakingCurrentFrame() override;
@@ -80,7 +82,7 @@ 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, std::shared_ptr<Broadcast> broadcast) override;
+        void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) override;
 
         void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
 
@@ -115,9 +117,9 @@ class Engine : public IEngine
         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<unsigned int, std::vector<Script *>> m_broadcastMap;
-        std::unordered_map<unsigned int, 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<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::vector<std::string> m_extensions;
         std::vector<std::shared_ptr<VirtualMachine>> m_runningScripts;
         std::vector<VirtualMachine *> m_scriptsToRemove;
diff --git a/src/scratch/costume.cpp b/src/scratch/costume.cpp
index 1d46d007..dbb6e1eb 100644
--- a/src/scratch/costume.cpp
+++ b/src/scratch/costume.cpp
@@ -48,3 +48,12 @@ void Costume::setRotationCenterY(int newRotationCenterY)
 {
     impl->rotationCenterY = newRotationCenterY;
 }
+
+/*!
+ * Returns the Broadcast linked with this costume.
+ * \note This is used by the "switch backdrop to and wait" block.
+ */
+Broadcast *Costume::broadcast()
+{
+    return &impl->broadcast;
+}
diff --git a/src/scratch/costume_p.cpp b/src/scratch/costume_p.cpp
index d0c0a4e9..0b70f216 100644
--- a/src/scratch/costume_p.cpp
+++ b/src/scratch/costume_p.cpp
@@ -4,6 +4,7 @@
 
 using namespace libscratchcpp;
 
-CostumePrivate::CostumePrivate()
+CostumePrivate::CostumePrivate() :
+    broadcast("", "")
 {
 }
diff --git a/src/scratch/costume_p.h b/src/scratch/costume_p.h
index 3d37f4bb..05c50a5d 100644
--- a/src/scratch/costume_p.h
+++ b/src/scratch/costume_p.h
@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include <scratchcpp/broadcast.h>
+
 namespace libscratchcpp
 {
 
@@ -13,6 +15,7 @@ struct CostumePrivate
         double bitmapResolution = 1;
         int rotationCenterX = 0;
         int rotationCenterY = 0;
+        Broadcast broadcast;
 };
 
 } // namespace libscratchcpp
diff --git a/test/assets/costume_test.cpp b/test/assets/costume_test.cpp
index 81fe327b..6ef79ed3 100644
--- a/test/assets/costume_test.cpp
+++ b/test/assets/costume_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/costume.h>
+#include <scratchcpp/broadcast.h>
 
 #include "../common.h"
 
@@ -39,3 +40,13 @@ TEST(CostumeTest, RotationCenterY)
     costume.setRotationCenterY(180);
     ASSERT_EQ(costume.rotationCenterY(), 180);
 }
+
+TEST(CostumeTest, Broadcast)
+{
+    Costume costume("costume1", "a", "svg");
+
+    Broadcast *broadcast = costume.broadcast();
+    ASSERT_TRUE(broadcast);
+    ASSERT_TRUE(broadcast->id().empty());
+    ASSERT_TRUE(broadcast->name().empty());
+}
diff --git a/test/backdrop_broadcasts.sb3 b/test/backdrop_broadcasts.sb3
new file mode 100644
index 00000000..30acc180
Binary files /dev/null and b/test/backdrop_broadcasts.sb3 differ
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 20ed514c..91e8c584 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -4,6 +4,8 @@
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/broadcast.h>
+#include <scratchcpp/stage.h>
+#include <scratchcpp/costume.h>
 #include <enginemock.h>
 
 #include "../common.h"
@@ -50,6 +52,14 @@ class EventBlocksTest : public testing::Test
             block->updateInputMap();
         }
 
+        void addValueField(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Fields id, const std::string &value) const
+        {
+            auto field = std::make_shared<Field>(name, value);
+            field->setFieldId(id);
+            block->addField(field);
+            block->updateFieldMap();
+        }
+
         void addBroadcastField(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Fields id, std::shared_ptr<Broadcast> broadcast) const
         {
             auto field = std::make_shared<Field>(name, Value(), broadcast);
@@ -77,16 +87,18 @@ TEST_F(EventBlocksTest, CategoryVisible)
 TEST_F(EventBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addHatBlock(m_section.get(), "event_whenflagclicked")).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcast", &EventBlocks::compileBroadcast)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcastandwait", &EventBlocks::compileBroadcastAndWait)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenbroadcastreceived", &EventBlocks::compileWhenBroadcastReceived)).Times(1);
+    EXPECT_CALL(m_engineMock, addHatBlock(m_section.get(), "event_whenflagclicked"));
+    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));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenbackdropswitchesto", &EventBlocks::compileWhenBackdropSwitchesTo));
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT)).Times(1);
 
     // Fields
     EXPECT_CALL(m_engineMock, addField(m_section.get(), "BROADCAST_OPTION", EventBlocks::BROADCAST_OPTION));
+    EXPECT_CALL(m_engineMock, addField(m_section.get(), "BACKDROP", EventBlocks::BACKDROP));
 
     m_section->registerBlocks(&m_engineMock);
 }
@@ -221,7 +233,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)).Times(1);
+    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, m_broadcast.get())).Times(1);
 
     compiler.init();
     compiler.setBlock(block1);
@@ -233,3 +245,29 @@ TEST_F(EventBlocksTest, WhenBroadcastReceived)
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
+
+TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
+{
+    Compiler compiler(&m_engineMock);
+    Stage stage;
+
+    // when backdrop switches to "backdrop2"
+    auto block1 = createEventBlock("a", "event_whenbackdropswitchesto");
+    addValueField(block1, "BACKDROP", EventBlocks::BACKDROP, "backdrop2");
+
+    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()));
+
+    compiler.init();
+    compiler.setBlock(block1);
+    EventBlocks::compileWhenBackdropSwitchesTo(&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());
+}
diff --git a/test/blocks/looks_blocks_test.cpp b/test/blocks/looks_blocks_test.cpp
index ca881bc5..665bcf46 100644
--- a/test/blocks/looks_blocks_test.cpp
+++ b/test/blocks/looks_blocks_test.cpp
@@ -105,6 +105,7 @@ TEST_F(LooksBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_switchcostumeto", &LooksBlocks::compileSwitchCostumeTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_nextcostume", &LooksBlocks::compileNextCostume));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_switchbackdropto", &LooksBlocks::compileSwitchBackdropTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_switchbackdroptoandwait", &LooksBlocks::compileSwitchBackdropToAndWait));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_nextbackdrop", &LooksBlocks::compileNextBackdrop));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_costumenumbername", &LooksBlocks::compileCostumeNumberName));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_backdropnumbername", &LooksBlocks::compileBackdropNumberName));
@@ -961,40 +962,527 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     vm.setConstValues(constValues);
 
     // "backdrop2"
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode1);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 2);
+
+    // 0
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 2);
+
+    stage.setCurrentCostume(1);
+
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 2);
+
+    // 1
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode3);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 1);
+
+    // 2
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode4);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 2);
+
+    // 3
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode5);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 1);
+
+    stage.setCurrentCostume(2);
+
+    // "2"
+    stage.addCostume(std::make_shared<Costume>("2", "b3", "svg"));
+    stage.addCostume(std::make_shared<Costume>("test", "b4", "svg"));
+    stage.setCurrentCostume(1);
+
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode6);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 3);
+
+    // "next backdrop"
+    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode7);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 4);
+
+    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 1);
+
+    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 2);
+
+    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));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 5);
+
+    // "previous backdrop"
+    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode8);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 4);
+
+    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 3);
+
+    stage.setCurrentCostume(1);
+
+    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, false));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 5);
+
+    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));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 6);
+
+    // -1 (index)
+    stage.setCurrentCostume(2);
+
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode9);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 6);
+
+    // 0 (index)
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode10);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 1);
+
+    // 5 (index)
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode11);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 6);
+
+    // 6 (index)
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    vm.setBytecode(bytecode12);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 1);
+}
+
+TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
+{
+    Target target;
+    Stage stage;
+    Compiler compiler(&m_engineMock, &target);
+
+    // switch backdrop to (backdrop2) and wait
+    auto block1 = std::make_shared<Block>("a", "looks_switchbackdroptoandwait");
+    addDropdownInput(block1, "BACKDROP", LooksBlocks::BACKDROP, "backdrop2");
+
+    // switch backdrop to (0) and wait
+    auto block2 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
+    addDropdownInput(block2, "BACKDROP", LooksBlocks::BACKDROP, "0");
+
+    // switch backdrop to (1) and wait
+    auto block3 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
+    addDropdownInput(block3, "BACKDROP", LooksBlocks::BACKDROP, "1");
+
+    // switch backdrop to (2) and wait
+    auto block4 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
+    addDropdownInput(block4, "BACKDROP", LooksBlocks::BACKDROP, "2");
+
+    // switch backdrop to (4) and wait
+    auto block5 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
+    addDropdownInput(block5, "BACKDROP", LooksBlocks::BACKDROP, "4");
+
+    // switch backdrop to (3) and wait - there's a backdrop with this name
+    auto block6 = std::make_shared<Block>("c", "looks_switchbackdroptoandwait");
+    addDropdownInput(block6, "BACKDROP", LooksBlocks::BACKDROP, "3");
+
+    // switch backdrop to (next backdrop) and wait
+    auto block7 = std::make_shared<Block>("d", "looks_switchbackdroptoandwait");
+    addDropdownInput(block7, "BACKDROP", LooksBlocks::BACKDROP, "next backdrop");
+
+    // switch backdrop to (next backdrop) and wait - there's a backdrop with this name
+    auto block8 = std::make_shared<Block>("d", "looks_switchbackdroptoandwait");
+    addDropdownInput(block8, "BACKDROP", LooksBlocks::BACKDROP, "next backdrop");
+
+    // switch backdrop to (previous backdrop) and wait
+    auto block9 = std::make_shared<Block>("e", "looks_switchbackdroptoandwait");
+    addDropdownInput(block9, "BACKDROP", LooksBlocks::BACKDROP, "previous backdrop");
+
+    // switch backdrop to (previous backdrop) and wait - there's a backdrop with this name
+    auto block10 = std::make_shared<Block>("f", "looks_switchbackdroptoandwait");
+    addDropdownInput(block10, "BACKDROP", LooksBlocks::BACKDROP, "previous backdrop");
+
+    // switch backdrop to (random backdrop) and wait
+    auto block11 = std::make_shared<Block>("g", "looks_switchbackdroptoandwait");
+    addDropdownInput(block11, "BACKDROP", LooksBlocks::BACKDROP, "random backdrop");
+
+    // switch backdrop to (random backdrop) and wait - there's a backdrop with this name
+    auto block12 = std::make_shared<Block>("h", "looks_switchbackdroptoandwait");
+    addDropdownInput(block12, "BACKDROP", LooksBlocks::BACKDROP, "random backdrop");
+
+    // switch backdrop to (join "" "") and wait
+    auto joinBlock = std::make_shared<Block>("j", "operator_join");
+    joinBlock->setCompileFunction(&OperatorBlocks::compileJoin);
+    auto block13 = std::make_shared<Block>("i", "looks_switchbackdroptoandwait");
+    addDropdownInput(block13, "BACKDROP", LooksBlocks::BACKDROP, "", joinBlock);
+
+    compiler.init();
+
+    // Test without any backdrops first
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
+    compiler.setBlock(block1);
+    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
+
+    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
+    compiler.setBlock(block1);
+    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
+
+    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    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::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::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::checkBackdropScripts)).WillOnce(Return(5));
+    compiler.setBlock(block5);
+    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
+
+    stage.addCostume(std::make_shared<Costume>("3", "b4", "svg"));
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    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::checkBackdropScripts)).WillOnce(Return(5));
+    compiler.setBlock(block7);
+    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
+
+    stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    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::checkBackdropScripts)).WillOnce(Return(5));
+    compiler.setBlock(block9);
+    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
+
+    stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    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::checkBackdropScripts)).WillOnce(Return(5));
+    compiler.setBlock(block11);
+    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
+
+    stage.addCostume(std::make_shared<Costume>("random backdrop", "b7", "svg"));
+
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    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::checkBackdropScripts)).WillOnce(Return(5));
+    compiler.setBlock(block13);
+    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(
+        compiler.bytecode(),
+        std::vector<unsigned int>(
+            { vm::OP_START,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              0,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              1,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              2,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              3,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              4,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              5,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_EXEC,
+              1,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              6,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_EXEC,
+              2,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              7,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_EXEC,
+              3,
+              vm::OP_EXEC,
+              5,
+              vm::OP_CONST,
+              8,
+              vm::OP_EXEC,
+              0,
+              vm::OP_EXEC,
+              5,
+              vm::OP_NULL,
+              vm::OP_NULL,
+              vm::OP_STR_CONCAT,
+              vm::OP_EXEC,
+              4,
+              vm::OP_EXEC,
+              5,
+              vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 1, -1, 0, 1, 3, 3, 4, 5, 6 }));
+}
+
+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 Value constValues[] = { "backdrop2", 0, 1, 2, 3, "next backdrop", "previous backdrop", -1, 0, 5, 6 };
+
+    Target target;
+
+    Stage stage;
+    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
+    stage.setCurrentCostume(1);
+
+    VirtualMachine vm(&target, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+    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, breakFrame());
     vm.setBytecode(bytecode1);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 2);
+    ASSERT_FALSE(vm.atEnd());
 
-    // 0
     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, breakFrame()).Times(0);
+    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, breakFrame());
     vm.setBytecode(bytecode2);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 2);
+    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, breakFrame()).Times(0);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_TRUE(vm.atEnd());
 
     stage.setCurrentCostume(1);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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));
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 2);
+    ASSERT_TRUE(vm.atEnd());
 
     // 1
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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, breakFrame()).Times(0);
     vm.setBytecode(bytecode3);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 1);
+    ASSERT_TRUE(vm.atEnd());
 
     // 2
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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, breakFrame()).Times(0);
     vm.setBytecode(bytecode4);
     vm.run();
 
@@ -1002,7 +1490,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.currentCostume(), 2);
 
     // 3
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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));
     vm.setBytecode(bytecode5);
     vm.run();
 
@@ -1016,7 +1506,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.addCostume(std::make_shared<Costume>("test", "b4", "svg"));
     stage.setCurrentCostume(1);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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));
     vm.setBytecode(bytecode6);
     vm.run();
 
@@ -1024,21 +1516,37 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.currentCostume(), 3);
 
     // "next backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    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, breakFrame());
     vm.setBytecode(bytecode7);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 4);
+    ASSERT_FALSE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    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, breakFrame()).Times(0);
+    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));
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 1);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    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));
     vm.reset();
     vm.run();
 
@@ -1047,7 +1555,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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));
     vm.reset();
     vm.run();
 
@@ -1055,14 +1565,28 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.currentCostume(), 5);
 
     // "previous backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    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, breakFrame());
     vm.setBytecode(bytecode8);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 4);
+    ASSERT_FALSE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    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, breakFrame()).Times(0);
+    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(2)->broadcast(), &vm, true));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -1071,7 +1595,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     stage.setCurrentCostume(1);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    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));
     vm.reset();
     vm.run();
 
@@ -1080,7 +1606,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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));
     vm.reset();
     vm.run();
 
@@ -1090,23 +1618,40 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     // -1 (index)
     stage.setCurrentCostume(2);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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, breakFrame());
     vm.setBytecode(bytecode9);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 6);
+    ASSERT_FALSE(vm.atEnd());
 
-    // 0 (index)
     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, breakFrame()).Times(0);
+    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));
     vm.setBytecode(bytecode10);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 1);
+    ASSERT_TRUE(vm.atEnd());
 
     // 5 (index)
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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));
     vm.setBytecode(bytecode11);
     vm.run();
 
@@ -1114,7 +1659,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.currentCostume(), 6);
 
     // 6 (index)
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    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));
     vm.setBytecode(bytecode12);
     vm.run();
 
@@ -1156,20 +1703,78 @@ TEST_F(LooksBlocksTest, NextBackdropImpl)
     vm.setBytecode(bytecode);
     vm.setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 2);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 3);
 
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 1);
+}
+
+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 };
+
+    Target target;
+
+    Stage stage;
+    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
+    stage.setCurrentCostume(1);
+
+    VirtualMachine vm(&target, &m_engineMock, nullptr);
+    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, breakFrame());
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 2);
+    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, breakFrame()).Times(0);
+    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));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 3);
+    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));
     vm.reset();
     vm.run();
 
@@ -1194,20 +1799,78 @@ TEST_F(LooksBlocksTest, PreviousBackdrop)
     vm.setBytecode(bytecode);
     vm.setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 2);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 1);
 
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 3);
+}
+
+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 };
+
+    Target target;
+
+    Stage stage;
+    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
+    stage.setCurrentCostume(3);
+
+    VirtualMachine vm(&target, &m_engineMock, nullptr);
+    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, breakFrame());
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 2);
+    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, breakFrame()).Times(0);
+    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));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 1);
+    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));
     vm.reset();
     vm.run();
 
@@ -1232,7 +1895,7 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
     LooksBlocks::rng = &rng;
 
     EXPECT_CALL(rng, randint).Times(0);
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -1242,7 +1905,8 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
     stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
 
     EXPECT_CALL(rng, randint(1, 3)).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
     vm.reset();
     vm.run();
 
@@ -1252,12 +1916,77 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
     stage.addCostume(std::make_shared<Costume>("backdrop4", "b4", "svg"));
 
     EXPECT_CALL(rng, randint(1, 4)).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 3);
+
+    LooksBlocks::rng = RandomGenerator::instance().get();
+}
+
+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 };
+
+    Target target;
+
+    Stage stage;
+
+    VirtualMachine vm(&target, &m_engineMock, nullptr);
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+
+    RandomGeneratorMock rng;
+    LooksBlocks::rng = &rng;
+
+    EXPECT_CALL(rng, randint).Times(0);
+    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning).Times(0);
+    EXPECT_CALL(m_engineMock, breakFrame()).Times(0);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+
+    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
+
+    EXPECT_CALL(rng, randint(1, 3)).WillOnce(Return(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(true));
+    EXPECT_CALL(m_engineMock, breakFrame());
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(stage.currentCostume(), 2);
+    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, breakFrame()).Times(0);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_TRUE(vm.atEnd());
+
+    stage.addCostume(std::make_shared<Costume>("backdrop4", "b4", "svg"));
+
+    EXPECT_CALL(rng, randint(1, 4)).WillOnce(Return(3));
+    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));
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.currentCostume(), 3);
+    ASSERT_TRUE(vm.atEnd());
 
     LooksBlocks::rng = RandomGenerator::instance().get();
 }
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index b621449c..44d14a7c 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -489,6 +489,31 @@ TEST(EngineTest, Clones)
     }
 }
 
+// TODO: Uncomment this after fixing #256 and #257
+/*TEST(EngineTest, BackdropBroadcasts)
+{
+    // TODO: Set "infinite" FPS (#254)
+    Project p("backdrop_broadcasts.sb3");
+    ASSERT_TRUE(p.load());
+    p.run();
+
+    auto engine = p.engine();
+
+    Target *stage = engine->targetAt(engine->findTarget("Stage"));
+    ASSERT_TRUE(stage);
+
+    ASSERT_VAR(stage, "test1");
+    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");
+    ASSERT_EQ(GET_VAR(stage, "test3")->value().toInt(), 10);
+    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 2 0 0");
+}*/
+
 TEST(EngineTest, NoCrashAfterStop)
 {
     // Regtest for #186
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 05a98083..04abeae4 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -19,6 +19,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, stop, (), (override));
         MOCK_METHOD(void, startScript, (std::shared_ptr<Block>, std::shared_ptr<Target>), (override));
         MOCK_METHOD(void, broadcast, (unsigned int, VirtualMachine *, bool), (override));
+        MOCK_METHOD(void, broadcastByPtr, (Broadcast *, VirtualMachine *, bool), (override));
         MOCK_METHOD(void, stopScript, (VirtualMachine *), (override));
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));
         MOCK_METHOD(void, initClone, (Sprite *), (override));
@@ -42,6 +43,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, setStageHeight, (unsigned int), (override));
 
         MOCK_METHOD(bool, broadcastRunning, (unsigned int, VirtualMachine *), (override));
+        MOCK_METHOD(bool, broadcastByPtrRunning, (Broadcast *, VirtualMachine *), (override));
 
         MOCK_METHOD(void, breakFrame, (), (override));
         MOCK_METHOD(bool, breakingCurrentFrame, (), (override));
@@ -66,7 +68,7 @@ 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>, std::shared_ptr<Broadcast>), (override));
+        MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, Broadcast *), (override));
 
         MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));