diff --git a/.github/workflows/utests-minimal.yml b/.github/workflows/utests-minimal.yml
new file mode 100644
index 00000000..00e02639
--- /dev/null
+++ b/.github/workflows/utests-minimal.yml
@@ -0,0 +1,28 @@
+name: Unit tests (minimal build)
+
+on:
+  push:
+    branches: '*'
+  pull_request:
+    branches: [ "master" ]
+
+env:
+  BUILD_TYPE: Debug
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+
+    - name: Configure CMake
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DLIBSCRATCHCPP_BUILD_UNIT_TESTS=ON -DLIBSCRATCHCPP_AUDIO_SUPPORT=OFF -DLIBSCRATCHCPP_NETWORK_SUPPORT=OFF -DLIBSCRATCHCPP_COMPUTED_GOTO=OFF
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j$(nproc --all)
+
+    - name: Run unit tests
+      run: ctest --test-dir build -V
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3d9a8456..66a900c7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.14)
 
-project(libscratchcpp VERSION 0.9.0 LANGUAGES C CXX)
+project(libscratchcpp VERSION 0.10.0 LANGUAGES C CXX)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_CXX_STANDARD 17)
diff --git a/README.md b/README.md
index 78dc3387..f4a9efbf 100644
--- a/README.md
+++ b/README.md
@@ -124,7 +124,7 @@ libscratchcpp::Project p("https://scratch.mit.edu/projects/XXXXXX");
 
 - [x] Motion blocks
 - [x] Looks blocks
-- [ ] Sound blocks
+- [x] Sound blocks
 - [x] Event blocks
 - [x] Control blocks
 - [ ] Sensing blocks
diff --git a/include/scratchcpp/block.h b/include/scratchcpp/block.h
index 02b7ddeb..fe6cf382 100644
--- a/include/scratchcpp/block.h
+++ b/include/scratchcpp/block.h
@@ -56,6 +56,12 @@ class LIBSCRATCHCPP_EXPORT Block : public Entity
 
         bool topLevel() const;
 
+        int x() const;
+        void setX(int x);
+
+        int y() const;
+        void setY(int y);
+
         std::shared_ptr<Comment> comment() const;
         const std::string &commentId() const;
         void setComment(std::shared_ptr<Comment> comment);
diff --git a/include/scratchcpp/compiler.h b/include/scratchcpp/compiler.h
index a8b852bb..05ab0c7c 100644
--- a/include/scratchcpp/compiler.h
+++ b/include/scratchcpp/compiler.h
@@ -4,6 +4,7 @@
 
 #include <vector>
 #include <memory>
+#include <unordered_set>
 
 #include "global.h"
 #include "spimpl.h"
@@ -82,6 +83,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         BlockPrototype *procedurePrototype() const;
         void setProcedurePrototype(BlockPrototype *prototype);
 
+        const std::unordered_set<std::string> &unsupportedBlocks() const;
+
     private:
         spimpl::unique_impl_ptr<CompilerPrivate> impl;
 };
diff --git a/include/scratchcpp/global.h b/include/scratchcpp/global.h
index 91500012..c72c14f6 100644
--- a/include/scratchcpp/global.h
+++ b/include/scratchcpp/global.h
@@ -23,12 +23,6 @@
 namespace libscratchcpp
 {
 
-enum class ScratchVersion
-{
-    Invalid = 0, /*!< An unsupported version. */
-    Scratch3 = 3 /*!< Scratch 3.0 */
-};
-
 class VirtualMachine;
 class Compiler;
 class Block;
diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 88e95521..aa5aac94 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -5,6 +5,7 @@
 #include <memory>
 #include <vector>
 #include <unordered_map>
+#include <unordered_set>
 #include <functional>
 
 #include "global.h"
@@ -60,7 +61,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *) = 0;
 
         /*! Starts the scripts of the broadcast with the given index. */
-        virtual void broadcast(unsigned int index) = 0;
+        virtual void broadcast(int index) = 0;
 
         /*! Starts the scripts of the given broadcast. */
         virtual void broadcastByPtr(Broadcast *broadcast) = 0;
@@ -87,6 +88,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Stops all currently playing sounds. */
         virtual void stopSounds() = 0;
 
+        /*! Returns the global volume of all sounds (in %). */
+        virtual double globalVolume() const = 0;
+
+        /*! Sets the global volume of all sounds (in %). */
+        virtual void setGlobalVolume(double volume) = 0;
+
         /*! Updates the values of stage monitors. */
         virtual void updateMonitors() = 0;
 
@@ -116,6 +123,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Emits when a script is about to stop. */
         virtual sigslot::signal<VirtualMachine *> &threadAboutToStop() = 0;
 
+        /*! Emits when the project is stopped by calling stop(). */
+        virtual sigslot::signal<> &stopped() = 0;
+
         /*! Returns true if the project is currently running. */
         virtual bool isRunning() const = 0;
 
@@ -282,12 +292,15 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the broadcast at index. */
         virtual std::shared_ptr<Broadcast> broadcastAt(int index) const = 0;
 
-        /*! Returns the index of the broadcast with the given name. */
-        virtual int findBroadcast(const std::string &broadcastName) const = 0;
+        /*! Returns the list of indexes of the broadcasts with the given name (case insensitive). */
+        virtual std::vector<int> findBroadcasts(const std::string &broadcastName) const = 0;
 
         /*! Returns the index of the broadcast with the given ID. */
         virtual int findBroadcastById(const std::string &broadcastId) const = 0;
 
+        /* Registers the given "when touching object" script. */
+        virtual void addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock) = 0;
+
         /*! Registers the "green flag" script. */
         virtual void addGreenFlagScript(std::shared_ptr<Block> hatBlock) = 0;
 
@@ -358,6 +371,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Emits when a question is asked, for example using the 'ask and wait' block. */
         virtual sigslot::signal<const std::string &> &questionAsked() = 0;
 
+        /*! Emits when the current question is aborted. */
+        virtual sigslot::signal<> &questionAborted() = 0;
+
         /*! Emits when a question is answered. */
         virtual sigslot::signal<const std::string &> &questionAnswered() = 0;
 
@@ -375,6 +391,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
 
         /*! Sets the user agent of the last person to edit the project. */
         virtual void setUserAgent(const std::string &agent) = 0;
+
+        /*! Returns the unsupported block opcodes which were found when compiling. */
+        virtual const std::unordered_set<std::string> &unsupportedBlocks() const = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/ispritehandler.h b/include/scratchcpp/ispritehandler.h
index 35173c03..9bfb4307 100644
--- a/include/scratchcpp/ispritehandler.h
+++ b/include/scratchcpp/ispritehandler.h
@@ -65,6 +65,12 @@ class LIBSCRATCHCPP_EXPORT ISpriteHandler
         /*! Called when the bubble text changes. */
         virtual void onBubbleTextChanged(const std::string &text) = 0;
 
+        /*! Used to get the current costume width. */
+        virtual int costumeWidth() const = 0;
+
+        /*! Used to get the current costume height. */
+        virtual int costumeHeight() const = 0;
+
         /*!
          * Used to get the bounding rectangle of the sprite.
          * \note The rectangle must be relative to the stage, so make sure to use the sprite's coordinates.
diff --git a/include/scratchcpp/istagehandler.h b/include/scratchcpp/istagehandler.h
index 31b3c7f3..0b397e17 100644
--- a/include/scratchcpp/istagehandler.h
+++ b/include/scratchcpp/istagehandler.h
@@ -46,6 +46,12 @@ class LIBSCRATCHCPP_EXPORT IStageHandler
         /*! Called when the bubble text changes. */
         virtual void onBubbleTextChanged(const std::string &text) = 0;
 
+        /*! Used to get the current costume width. */
+        virtual int costumeWidth() const = 0;
+
+        /*! Used to get the current costume height. */
+        virtual int costumeHeight() const = 0;
+
         /*! Used to get the bounding rectangle of the stage. */
         virtual Rect boundingRect() const = 0;
 
diff --git a/include/scratchcpp/project.h b/include/scratchcpp/project.h
index 414ae47b..6f1c455c 100644
--- a/include/scratchcpp/project.h
+++ b/include/scratchcpp/project.h
@@ -26,7 +26,6 @@ class LIBSCRATCHCPP_EXPORT Project
     public:
         Project();
         Project(const std::string &fileName);
-        Project(const std::string &fileName, ScratchVersion scratchVersion);
         Project(const Project &) = delete;
 
         bool load();
@@ -38,9 +37,6 @@ class LIBSCRATCHCPP_EXPORT Project
         const std::string &fileName() const;
         void setFileName(const std::string &newFileName);
 
-        ScratchVersion scratchVersion() const;
-        void setScratchVersion(const ScratchVersion &version);
-
         std::shared_ptr<IEngine> engine() const;
 
         sigslot::signal<unsigned int, unsigned int> &downloadProgressChanged();
diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index fe3a44ee..b82aaf48 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -35,7 +35,7 @@ class LIBSCRATCHCPP_EXPORT Script
         void setBytecode(const std::vector<unsigned int> &code);
 
         void setHatPredicateBytecode(const std::vector<unsigned int> &code);
-        bool runHatPredicate();
+        bool runHatPredicate(Target *target);
 
         void setProcedures(const std::vector<unsigned int *> &procedures);
         void setConstValues(const std::vector<Value> &values);
diff --git a/include/scratchcpp/sound.h b/include/scratchcpp/sound.h
index 4185ade0..90f5abc7 100644
--- a/include/scratchcpp/sound.h
+++ b/include/scratchcpp/sound.h
@@ -9,12 +9,19 @@
 namespace libscratchcpp
 {
 
+class Target;
 class SoundPrivate;
 
 /*! \brief The Sound class represents a Scratch sound. */
 class LIBSCRATCHCPP_EXPORT Sound : public Asset
 {
     public:
+        enum class Effect
+        {
+            Pitch,
+            Pan
+        };
+
         Sound(const std::string &name, const std::string &id, const std::string &format);
         Sound(const Sound &) = delete;
         virtual ~Sound() { }
@@ -26,11 +33,15 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
         void setSampleCount(int newSampleCount);
 
         virtual void setVolume(double volume);
+        virtual void setEffect(Effect effect, double value);
 
         virtual void start();
         virtual void stop();
 
-        virtual bool isPlaying();
+        virtual bool isPlaying() const;
+
+        Target *target() const;
+        void setTarget(Target *target);
 
         std::shared_ptr<Sound> clone() const;
 
@@ -38,6 +49,8 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
         void processData(unsigned int size, void *data) override;
 
     private:
+        void stopCloneSounds();
+
         spimpl::unique_impl_ptr<SoundPrivate> impl;
 };
 
diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
index 97805772..328c6371 100644
--- a/include/scratchcpp/sprite.h
+++ b/include/scratchcpp/sprite.h
@@ -59,6 +59,9 @@ class LIBSCRATCHCPP_EXPORT Sprite
 
         void setCostumeIndex(int newCostumeIndex) override;
 
+        int currentCostumeWidth() const override;
+        int currentCostumeHeight() const override;
+
         double direction() const;
         void setDirection(double newDirection);
 
diff --git a/include/scratchcpp/stage.h b/include/scratchcpp/stage.h
index 5c6b1564..0d37c862 100644
--- a/include/scratchcpp/stage.h
+++ b/include/scratchcpp/stage.h
@@ -33,6 +33,9 @@ class LIBSCRATCHCPP_EXPORT Stage : public Target
 
         void setCostumeIndex(int newCostumeIndex) override;
 
+        int currentCostumeWidth() const override;
+        int currentCostumeHeight() const override;
+
         int tempo() const;
         void setTempo(int newTempo);
 
diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index 8007bf31..cb8f7c1b 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -7,6 +7,7 @@
 #include "global.h"
 #include "spimpl.h"
 #include "rect.h"
+#include "sound.h"
 
 namespace libscratchcpp
 {
@@ -69,6 +70,8 @@ class LIBSCRATCHCPP_EXPORT Target
         virtual void setCostumeIndex(int newCostumeIndex);
 
         std::shared_ptr<Costume> currentCostume() const;
+        virtual int currentCostumeWidth() const;
+        virtual int currentCostumeHeight() const;
 
         const std::vector<std::shared_ptr<Costume>> &costumes() const;
         int addCostume(std::shared_ptr<Costume> costume);
@@ -86,6 +89,11 @@ class LIBSCRATCHCPP_EXPORT Target
         double volume() const;
         void setVolume(double newVolume);
 
+        virtual double soundEffectValue(Sound::Effect effect) const;
+        virtual void setSoundEffectValue(Sound::Effect effect, double value);
+
+        virtual void clearSoundEffects();
+
         virtual Rect boundingRect() const;
         virtual Rect fastBoundingRect() const;
 
diff --git a/include/scratchcpp/value.h b/include/scratchcpp/value.h
index fa53716a..94baeb55 100644
--- a/include/scratchcpp/value.h
+++ b/include/scratchcpp/value.h
@@ -8,8 +8,8 @@
 #include <ctgmath>
 #include <cassert>
 #include <iomanip>
-#include <utf8.h>
 #include <iostream>
+#include <clocale>
 
 #include "global.h"
 
@@ -369,7 +369,7 @@ class LIBSCRATCHCPP_EXPORT Value
         };
 
         /*! Returns the UTF-16 representation of the value. */
-        std::u16string toUtf16() const { return utf8::utf8to16(toString()); };
+        std::u16string toUtf16() const;
 
         /*! Adds the given value to the value. */
         void add(const Value &v)
diff --git a/src/audio/CMakeLists.txt b/src/audio/CMakeLists.txt
index 5bf4e0b3..536c266b 100644
--- a/src/audio/CMakeLists.txt
+++ b/src/audio/CMakeLists.txt
@@ -15,6 +15,7 @@ endif()
 
 target_sources(scratchcpp-audio
   PUBLIC
+    iaudioengine.h
     iaudioplayer.h
     iaudiooutput.h
     audiooutput.cpp
@@ -38,6 +39,8 @@ if (LIBSCRATCHCPP_AUDIO_SUPPORT)
 else()
     target_sources(scratchcpp-audio
       PUBLIC
+        internal/audioenginestub.cpp
+        internal/audioenginestub.h
         internal/audioplayerstub.cpp
         internal/audioplayerstub.h
         internal/audioloudnessstub.cpp
diff --git a/src/audio/iaudioengine.h b/src/audio/iaudioengine.h
new file mode 100644
index 00000000..8100334b
--- /dev/null
+++ b/src/audio/iaudioengine.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+namespace libscratchcpp
+{
+
+class IAudioEngine
+{
+    public:
+        virtual ~IAudioEngine() { }
+
+        static IAudioEngine *instance();
+
+        virtual float volume() const = 0;
+        virtual void setVolume(float volume) = 0;
+};
+
+} // namespace libscratchcpp
diff --git a/src/audio/iaudioplayer.h b/src/audio/iaudioplayer.h
index 0023f195..0531c8ed 100644
--- a/src/audio/iaudioplayer.h
+++ b/src/audio/iaudioplayer.h
@@ -16,6 +16,12 @@ class IAudioPlayer
         virtual float volume() const = 0;
         virtual void setVolume(float volume) = 0;
 
+        virtual float pitch() const = 0;
+        virtual void setPitch(float pitch) = 0;
+
+        virtual float pan() const = 0;
+        virtual void setPan(float pan) = 0;
+
         virtual bool isLoaded() const = 0;
 
         virtual void start() = 0;
diff --git a/src/audio/internal/audioengine.cpp b/src/audio/internal/audioengine.cpp
index 710a394e..1af3874d 100644
--- a/src/audio/internal/audioengine.cpp
+++ b/src/audio/internal/audioengine.cpp
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <iostream>
+#include <miniaudio.h>
 
 #include "audioengine.h"
 
@@ -8,12 +9,17 @@ using namespace libscratchcpp;
 
 AudioEngine AudioEngine::instance;
 
+IAudioEngine *IAudioEngine::instance()
+{
+    return &AudioEngine::instance;
+}
+
 ma_engine *AudioEngine::engine()
 {
     if (!instance.m_initialized)
         instance.init();
 
-    return instance.m_initialized ? &instance.m_engine : nullptr;
+    return instance.m_initialized ? instance.m_engine : nullptr;
 }
 
 bool AudioEngine::initialized()
@@ -24,20 +30,36 @@ bool AudioEngine::initialized()
     return instance.m_initialized;
 }
 
+float AudioEngine::volume() const
+{
+    return m_volume;
+}
+
+void AudioEngine::setVolume(float volume)
+{
+    m_volume = volume;
+
+    if (m_initialized)
+        ma_engine_set_volume(m_engine, volume);
+}
+
 AudioEngine::AudioEngine()
 {
 }
 
 AudioEngine::~AudioEngine()
 {
-    if (m_initialized)
-        ma_engine_uninit(&m_engine);
+    if (m_initialized && m_engine) {
+        ma_engine_uninit(m_engine);
+        delete m_engine;
+    }
 }
 
 void AudioEngine::init()
 {
     ma_result result;
-    result = ma_engine_init(NULL, &m_engine);
+    m_engine = new ma_engine;
+    result = ma_engine_init(NULL, m_engine);
 
     if (result != MA_SUCCESS) {
         std::cerr << "Failed to initialize audio engine." << std::endl;
diff --git a/src/audio/internal/audioengine.h b/src/audio/internal/audioengine.h
index 49097871..02672ff3 100644
--- a/src/audio/internal/audioengine.h
+++ b/src/audio/internal/audioengine.h
@@ -3,18 +3,26 @@
 #pragma once
 
 #include <memory>
-#include <miniaudio.h>
+
+#include "../iaudioengine.h"
+
+struct ma_engine;
 
 namespace libscratchcpp
 {
 
 // This is a singleton which initializes and uninitializes the miniaudio engine
-class AudioEngine
+class AudioEngine : public IAudioEngine
 {
     public:
+        friend class IAudioEngine;
+
         static ma_engine *engine();
         static bool initialized();
 
+        float volume() const override;
+        void setVolume(float volume) override;
+
     private:
         AudioEngine();
         ~AudioEngine();
@@ -22,8 +30,10 @@ class AudioEngine
         void init();
 
         static AudioEngine instance;
-        ma_engine m_engine;
+
+        ma_engine *m_engine = nullptr;
         bool m_initialized = false;
+        float m_volume = 1.0f;
 };
 
 } // namespace libscratchcpp
diff --git a/src/audio/internal/audioenginestub.cpp b/src/audio/internal/audioenginestub.cpp
new file mode 100644
index 00000000..83b8bd45
--- /dev/null
+++ b/src/audio/internal/audioenginestub.cpp
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "audioenginestub.h"
+
+using namespace libscratchcpp;
+
+AudioEngineStub AudioEngineStub::instance;
+
+IAudioEngine *IAudioEngine::instance()
+{
+    return &AudioEngineStub::instance;
+}
+
+AudioEngineStub::AudioEngineStub()
+{
+}
+
+float AudioEngineStub::volume() const
+{
+    return m_volume;
+}
+
+void AudioEngineStub::setVolume(float volume)
+{
+    m_volume = volume;
+}
diff --git a/src/audio/internal/audioenginestub.h b/src/audio/internal/audioenginestub.h
new file mode 100644
index 00000000..e49e076c
--- /dev/null
+++ b/src/audio/internal/audioenginestub.h
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "../iaudioengine.h"
+
+namespace libscratchcpp
+{
+
+class AudioEngineStub : public IAudioEngine
+{
+    public:
+        friend class IAudioEngine;
+        AudioEngineStub();
+
+        float volume() const override;
+        void setVolume(float volume) override;
+
+    private:
+        static AudioEngineStub instance;
+        float m_volume = 1.0f;
+};
+
+} // namespace libscratchcpp
diff --git a/src/audio/internal/audioplayer.cpp b/src/audio/internal/audioplayer.cpp
index 9cab04ba..dce100fb 100644
--- a/src/audio/internal/audioplayer.cpp
+++ b/src/audio/internal/audioplayer.cpp
@@ -2,6 +2,7 @@
 
 #include <iostream>
 #include <cassert>
+#include <miniaudio.h>
 
 #include "audioplayer.h"
 #include "audioengine.h"
@@ -18,11 +19,15 @@ AudioPlayer::~AudioPlayer()
 {
     if (m_loaded) {
         ma_sound_uninit(m_sound);
-        ma_decoder_uninit(m_decoder);
+
+        if (!m_copy)
+            ma_decoder_uninit(m_decoder);
     }
 
-    delete m_decoder;
     delete m_sound;
+
+    if (!m_copy)
+        delete m_decoder;
 }
 
 bool AudioPlayer::load(unsigned int size, const void *data, unsigned long sampleRate)
@@ -53,6 +58,8 @@ bool AudioPlayer::load(unsigned int size, const void *data, unsigned long sample
 
     m_loaded = true;
     ma_sound_set_volume(m_sound, m_volume);
+    ma_sound_set_pitch(m_sound, m_pitch);
+    ma_sound_set_pan(m_sound, m_pan);
     return true;
 }
 
@@ -74,7 +81,10 @@ bool AudioPlayer::loadCopy(IAudioPlayer *player)
     }
 
     m_loaded = true;
+    m_copy = true;
     ma_sound_set_volume(m_sound, m_volume);
+    ma_sound_set_pitch(m_sound, m_pitch);
+    ma_sound_set_pan(m_sound, m_pan);
     return true;
 }
 
@@ -93,6 +103,44 @@ void AudioPlayer::setVolume(float volume)
     ma_sound_set_volume(m_sound, volume);
 }
 
+float AudioPlayer::pitch() const
+{
+    return m_pitch;
+}
+
+void AudioPlayer::setPitch(float pitch)
+{
+    /*
+     * 0.5 -> 220 Hz
+     * 1 -> 440 Hz
+     * 2 -> 880 Hz
+     * 4 -> 1760 Hz
+     * ...
+     */
+    m_pitch = pitch;
+
+    if (!m_loaded)
+        return;
+
+    ma_sound_set_pitch(m_sound, pitch);
+}
+
+float AudioPlayer::pan() const
+{
+    return m_pan;
+}
+
+void AudioPlayer::setPan(float pan)
+{
+    // -1 ... 0 ... 1
+    m_pan = pan;
+
+    if (!m_loaded)
+        return;
+
+    ma_sound_set_pan(m_sound, pan);
+}
+
 bool AudioPlayer::isLoaded() const
 {
     return m_loaded;
diff --git a/src/audio/internal/audioplayer.h b/src/audio/internal/audioplayer.h
index 854691ae..ad5a2e0d 100644
--- a/src/audio/internal/audioplayer.h
+++ b/src/audio/internal/audioplayer.h
@@ -22,6 +22,12 @@ class AudioPlayer : public IAudioPlayer
         float volume() const override;
         void setVolume(float volume) override;
 
+        float pitch() const override;
+        void setPitch(float pitch) override;
+
+        float pan() const override;
+        void setPan(float pan) override;
+
         bool isLoaded() const override;
 
         void start() override;
@@ -33,8 +39,11 @@ class AudioPlayer : public IAudioPlayer
         ma_decoder *m_decoder = nullptr;
         ma_sound *m_sound;
         bool m_loaded = false;
+        bool m_copy = false;
         bool m_started = false;
         float m_volume = 1;
+        float m_pitch = 1;
+        float m_pan = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/src/audio/internal/audioplayerstub.cpp b/src/audio/internal/audioplayerstub.cpp
index 82983f1c..0dc39939 100644
--- a/src/audio/internal/audioplayerstub.cpp
+++ b/src/audio/internal/audioplayerstub.cpp
@@ -28,6 +28,26 @@ void AudioPlayerStub::setVolume(float volume)
     m_volume = volume;
 }
 
+float AudioPlayerStub::pitch() const
+{
+    return m_pitch;
+}
+
+void AudioPlayerStub::setPitch(float pitch)
+{
+    m_pitch = pitch;
+}
+
+float AudioPlayerStub::pan() const
+{
+    return m_pan;
+}
+
+void AudioPlayerStub::setPan(float pan)
+{
+    m_pan = pan;
+}
+
 bool AudioPlayerStub::isLoaded() const
 {
     return true;
diff --git a/src/audio/internal/audioplayerstub.h b/src/audio/internal/audioplayerstub.h
index a577ddb2..c8c297cf 100644
--- a/src/audio/internal/audioplayerstub.h
+++ b/src/audio/internal/audioplayerstub.h
@@ -18,6 +18,12 @@ class AudioPlayerStub : public IAudioPlayer
         float volume() const override;
         void setVolume(float volume) override;
 
+        float pitch() const override;
+        void setPitch(float pitch) override;
+
+        float pan() const override;
+        void setPan(float pan) override;
+
         bool isLoaded() const override;
 
         void start() override;
@@ -27,6 +33,8 @@ class AudioPlayerStub : public IAudioPlayer
 
     private:
         float m_volume = 1;
+        float m_pitch = 1;
+        float m_pan = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/src/blocks/controlblocks.cpp b/src/blocks/controlblocks.cpp
index d3f89b07..0f965123 100644
--- a/src/blocks/controlblocks.cpp
+++ b/src/blocks/controlblocks.cpp
@@ -175,8 +175,7 @@ void ControlBlocks::compileCreateClone(Compiler *compiler)
 {
     Input *input = compiler->input(CLONE_OPTION);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string spriteName = input->selectedMenuItem();
 
         if (spriteName == "_myself_")
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 282437c6..e4c61902 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -6,6 +6,7 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/block.h>
@@ -27,6 +28,7 @@ std::string EventBlocks::name() const
 void EventBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
+    engine->addCompileFunction(this, "event_whentouchingobject", &compileWhenTouchingObject);
     engine->addCompileFunction(this, "event_whenflagclicked", &compileWhenFlagClicked);
     engine->addCompileFunction(this, "event_whenthisspriteclicked", &compileWhenThisSpriteClicked);
     engine->addCompileFunction(this, "event_whenstageclicked", &compileWhenStageClicked);
@@ -38,9 +40,11 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "event_whenkeypressed", &compileWhenKeyPressed);
 
     // Hat predicates
+    engine->addHatPredicateCompileFunction(this, "event_whentouchingobject", &compileWhenTouchingObjectPredicate);
     engine->addHatPredicateCompileFunction(this, "event_whengreaterthan", &compileWhenGreaterThanPredicate);
 
     // Inputs
+    engine->addInput(this, "TOUCHINGOBJECTMENU", TOUCHINGOBJECTMENU);
     engine->addInput(this, "BROADCAST_INPUT", BROADCAST_INPUT);
     engine->addInput(this, "VALUE", VALUE);
 
@@ -55,6 +59,26 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addFieldValue(this, "TIMER", Timer);
 }
 
+void EventBlocks::compileWhenTouchingObjectPredicate(Compiler *compiler)
+{
+    Input *input = compiler->input(TOUCHINGOBJECTMENU);
+
+    if (input->pointsToDropdownMenu()) {
+        std::string value = input->selectedMenuItem();
+
+        compiler->addConstValue(value);
+        compiler->addFunctionCall(&whenTouchingObjectPredicate);
+    } else {
+        compiler->addInput(input);
+        compiler->addFunctionCall(&whenTouchingObjectPredicate);
+    }
+}
+
+void EventBlocks::compileWhenTouchingObject(Compiler *compiler)
+{
+    compiler->engine()->addWhenTouchingObjectScript(compiler->block());
+}
+
 void EventBlocks::compileWhenFlagClicked(Compiler *compiler)
 {
     compiler->engine()->addGreenFlagScript(compiler->block());
@@ -75,8 +99,12 @@ void EventBlocks::compileBroadcast(Compiler *compiler)
     auto input = compiler->input(BROADCAST_INPUT);
 
     if (input->type() != Input::Type::ObscuredShadow) {
-        compiler->addConstValue(compiler->engine()->findBroadcast(input->primaryValue()->value().toString()));
-        compiler->addFunctionCall(&broadcastByIndex);
+        std::vector<int> broadcasts = compiler->engine()->findBroadcasts(input->primaryValue()->value().toString());
+
+        for (int index : broadcasts) {
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&broadcastByIndex);
+        }
     } else {
         compiler->addInput(input);
         compiler->addFunctionCall(&broadcast);
@@ -88,11 +116,17 @@ void EventBlocks::compileBroadcastAndWait(Compiler *compiler)
     auto input = compiler->input(BROADCAST_INPUT);
 
     if (input->type() != Input::Type::ObscuredShadow) {
-        int index = compiler->engine()->findBroadcast(input->primaryValue()->value().toString());
-        compiler->addConstValue(index);
-        compiler->addFunctionCall(&broadcastByIndexAndWait);
-        compiler->addConstValue(index);
-        compiler->addFunctionCall(&checkBroadcastByIndex);
+        std::vector<int> broadcasts = compiler->engine()->findBroadcasts(input->primaryValue()->value().toString());
+
+        for (int index : broadcasts) {
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&broadcastByIndexAndWait);
+        }
+
+        for (int index : broadcasts) {
+            compiler->addConstValue(index);
+            compiler->addFunctionCall(&checkBroadcastByIndex);
+        }
     } else {
         compiler->addInput(input);
         compiler->addFunctionCall(&broadcastAndWait);
@@ -151,9 +185,33 @@ void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
     compiler->engine()->addKeyPressScript(compiler->block(), KEY_OPTION);
 }
 
+unsigned int EventBlocks::whenTouchingObjectPredicate(VirtualMachine *vm)
+{
+    std::string value = vm->getInput(0, 1)->toString();
+
+    if (value == "_mouse_")
+        vm->replaceReturnValue(vm->target()->touchingPoint(vm->engine()->mouseX(), vm->engine()->mouseY()), 1);
+    else if (value == "_edge_")
+        vm->replaceReturnValue(vm->target()->touchingEdge(), 1);
+    else {
+        Target *target = vm->engine()->targetAt(vm->engine()->findTarget(value));
+
+        if (target && !target->isStage())
+            vm->replaceReturnValue(vm->target()->touchingSprite(static_cast<Sprite *>(target)), 1);
+        else
+            vm->replaceReturnValue(false, 1);
+    }
+
+    return 0;
+}
+
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
+    std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());
+
+    for (int index : broadcasts)
+        vm->engine()->broadcast(index);
+
     return 1;
 }
 
@@ -165,7 +223,11 @@ unsigned int EventBlocks::broadcastByIndex(VirtualMachine *vm)
 
 unsigned int EventBlocks::broadcastAndWait(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
+    std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());
+
+    for (int index : broadcasts)
+        vm->engine()->broadcast(index);
+
     return 1;
 }
 
@@ -177,8 +239,20 @@ unsigned int EventBlocks::broadcastByIndexAndWait(VirtualMachine *vm)
 
 unsigned int EventBlocks::checkBroadcast(VirtualMachine *vm)
 {
-    if (vm->engine()->broadcastRunning(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString())))
+    bool running = false;
+
+    std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());
+
+    for (int index : broadcasts) {
+        if (vm->engine()->broadcastRunning(index)) {
+            running = true;
+            break;
+        }
+    }
+
+    if (running)
         vm->stop(true, true, true);
+
     return 1;
 }
 
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
index 49479da7..0c5e5fd6 100644
--- a/src/blocks/eventblocks.h
+++ b/src/blocks/eventblocks.h
@@ -17,6 +17,7 @@ class EventBlocks : public IBlockSection
     public:
         enum Inputs
         {
+            TOUCHINGOBJECTMENU,
             BROADCAST_INPUT,
             VALUE
         };
@@ -39,6 +40,8 @@ class EventBlocks : public IBlockSection
 
         void registerBlocks(IEngine *engine) override;
 
+        static void compileWhenTouchingObjectPredicate(Compiler *compiler);
+        static void compileWhenTouchingObject(Compiler *compiler);
         static void compileWhenFlagClicked(Compiler *compiler);
         static void compileWhenThisSpriteClicked(Compiler *compiler);
         static void compileWhenStageClicked(Compiler *compiler);
@@ -50,6 +53,8 @@ class EventBlocks : public IBlockSection
         static void compileWhenGreaterThan(Compiler *compiler);
         static void compileWhenKeyPressed(Compiler *compiler);
 
+        static unsigned int whenTouchingObjectPredicate(VirtualMachine *vm);
+
         static unsigned int broadcast(VirtualMachine *vm);
         static unsigned int broadcastByIndex(VirtualMachine *vm);
         static unsigned int broadcastAndWait(VirtualMachine *vm);
diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index b10691a4..fb55f39d 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -103,6 +103,15 @@ void LooksBlocks::onInit(IEngine *engine)
         m_timeMap.erase(vm);
         erase_if(m_waitingBubbles, [vm](const std::pair<Target *, VirtualMachine *> &pair) { return pair.second == vm; });
     });
+
+    engine->stopped().connect([engine]() {
+        const auto &targets = engine->targets();
+
+        for (auto target : targets) {
+            target->setBubbleText("");
+            target->clearGraphicsEffects();
+        }
+    });
 }
 
 void LooksBlocks::compileSayForSecs(Compiler *compiler)
@@ -340,8 +349,7 @@ void LooksBlocks::compileSwitchCostumeTo(Compiler *compiler)
 
     Input *input = compiler->input(COSTUME);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
         int index = target->findCostume(value);
 
@@ -385,8 +393,7 @@ void LooksBlocks::compileSwitchBackdropTo(Compiler *compiler)
 
     Input *input = compiler->input(BACKDROP);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
         int index = stage->findCostume(value);
 
@@ -427,8 +434,7 @@ void LooksBlocks::compileSwitchBackdropToAndWait(Compiler *compiler)
 
     Input *input = compiler->input(BACKDROP);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
         int index = stage->findCostume(value);
 
diff --git a/src/blocks/motionblocks.cpp b/src/blocks/motionblocks.cpp
index 012d436d..549cb18d 100644
--- a/src/blocks/motionblocks.cpp
+++ b/src/blocks/motionblocks.cpp
@@ -107,8 +107,7 @@ void MotionBlocks::compilePointTowards(Compiler *compiler)
 {
     Input *input = compiler->input(TOWARDS);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
@@ -137,8 +136,7 @@ void MotionBlocks::compileGoTo(Compiler *compiler)
 {
     Input *input = compiler->input(TO);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
@@ -171,8 +169,7 @@ void MotionBlocks::compileGlideTo(Compiler *compiler)
 
     Input *input = compiler->input(TO);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
diff --git a/src/blocks/sensingblocks.cpp b/src/blocks/sensingblocks.cpp
index 722be78a..fee64bc0 100644
--- a/src/blocks/sensingblocks.cpp
+++ b/src/blocks/sensingblocks.cpp
@@ -95,12 +95,27 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->questionAnswered().connect(&onAnswer);
 }
 
+void SensingBlocks::onInit(IEngine *engine)
+{
+    engine->threadAboutToStop().connect([engine](VirtualMachine *thread) {
+        if (!m_questionList.empty()) {
+            // Abort the question of this thread if it's currently being displayed
+            if (m_questionList.front()->vm == thread) {
+                thread->target()->setBubbleText("");
+                engine->questionAborted()();
+            }
+
+            m_questionList
+                .erase(std::remove_if(m_questionList.begin(), m_questionList.end(), [thread](const std::unique_ptr<Question> &question) { return question->vm == thread; }), m_questionList.end());
+        }
+    });
+}
+
 void SensingBlocks::compileTouchingObject(Compiler *compiler)
 {
     Input *input = compiler->input(TOUCHINGOBJECTMENU);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
@@ -128,8 +143,7 @@ void SensingBlocks::compileDistanceTo(Compiler *compiler)
 {
     Input *input = compiler->input(DISTANCETOMENU);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         if (value == "_mouse_")
@@ -224,8 +238,7 @@ void SensingBlocks::compileOf(Compiler *compiler)
     assert(input);
     BlockFunc f = nullptr;
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         IEngine *engine = compiler->engine();
@@ -276,13 +289,16 @@ void SensingBlocks::compileOf(Compiler *compiler)
 
             default: {
                 // Variable
+                f = &variableOfTargetByIndex;
                 Target *target = engine->targetAt(index);
                 auto varIndex = target->findVariable(property->value().toString());
 
                 if (varIndex == -1)
                     compiler->addInstruction(vm::OP_NULL);
-                else
-                    compiler->addInstruction(vm::OP_READ_VAR, { compiler->variableIndex(target->variableAt(varIndex)) });
+                else {
+                    // NOTE: The OP_READ_VAR instruction can't be used for this (see #548)
+                    compiler->addConstValue(varIndex);
+                }
 
                 break;
             }
@@ -869,6 +885,19 @@ unsigned int SensingBlocks::variableOfTarget(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int SensingBlocks::variableOfTargetByIndex(VirtualMachine *vm)
+{
+    Target *target = vm->engine()->targetAt(vm->getInput(0, 1)->toInt());
+
+    if (target) {
+        const int varIndex = vm->getInput(0, 2)->toInt();
+        vm->replaceReturnValue(target->variableAt(varIndex)->value(), 2);
+    } else
+        vm->replaceReturnValue(0, 2);
+
+    return 1;
+}
+
 unsigned int SensingBlocks::backdropNumberOfStage(VirtualMachine *vm)
 {
     Target *target = vm->engine()->targetAt(vm->engine()->findTarget(vm->getInput(0, 1)->toString()));
diff --git a/src/blocks/sensingblocks.h b/src/blocks/sensingblocks.h
index 032c0561..e281827f 100644
--- a/src/blocks/sensingblocks.h
+++ b/src/blocks/sensingblocks.h
@@ -60,6 +60,7 @@ class SensingBlocks : public IBlockSection
         std::string name() const override;
 
         void registerBlocks(IEngine *engine) override;
+        void onInit(IEngine *engine) override;
 
         static void compileTouchingObject(Compiler *compiler);
         static void compileTouchingColor(Compiler *compiler);
@@ -131,6 +132,7 @@ class SensingBlocks : public IBlockSection
         static unsigned int volumeOfTarget(VirtualMachine *vm);
         static unsigned int volumeOfTargetByIndex(VirtualMachine *vm);
         static unsigned int variableOfTarget(VirtualMachine *vm);
+        static unsigned int variableOfTargetByIndex(VirtualMachine *vm);
         static unsigned int backdropNumberOfStage(VirtualMachine *vm);
         static unsigned int backdropNumberOfStageByIndex(VirtualMachine *vm);
         static unsigned int backdropNameOfStage(VirtualMachine *vm);
diff --git a/src/blocks/soundblocks.cpp b/src/blocks/soundblocks.cpp
index fb999b87..4eb311fa 100644
--- a/src/blocks/soundblocks.cpp
+++ b/src/blocks/soundblocks.cpp
@@ -4,6 +4,7 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/target.h>
 #include <scratchcpp/input.h>
+#include <scratchcpp/field.h>
 #include <scratchcpp/sound.h>
 
 #include "soundblocks.h"
@@ -33,7 +34,10 @@ void SoundBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sound_play", &compilePlay);
     engine->addCompileFunction(this, "sound_playuntildone", &compilePlayUntilDone);
     engine->addCompileFunction(this, "sound_stopallsounds", &compileStopAllSounds);
+    engine->addCompileFunction(this, "sound_seteffectto", &compileSetEffectTo);
+    engine->addCompileFunction(this, "sound_changeeffectby", &compileChangeEffectBy);
     engine->addCompileFunction(this, "sound_changevolumeby", &compileChangeVolumeBy);
+    engine->addCompileFunction(this, "sound_cleareffects", &compileClearEffects);
     engine->addCompileFunction(this, "sound_setvolumeto", &compileSetVolumeTo);
     engine->addCompileFunction(this, "sound_volume", &compileVolume);
 
@@ -42,7 +46,15 @@ void SoundBlocks::registerBlocks(IEngine *engine)
 
     // Inputs
     engine->addInput(this, "SOUND_MENU", SOUND_MENU);
+    engine->addInput(this, "VALUE", VALUE);
     engine->addInput(this, "VOLUME", VOLUME);
+
+    // Fields
+    engine->addField(this, "EFFECT", EFFECT);
+
+    // Field values
+    engine->addFieldValue(this, "PITCH", PITCH);
+    engine->addFieldValue(this, "PAN", PAN);
 }
 
 void SoundBlocks::onInit(IEngine *engine)
@@ -61,8 +73,7 @@ bool SoundBlocks::compilePlayCommon(Compiler *compiler, bool untilDone, bool *by
 
     Input *input = compiler->input(SOUND_MENU);
 
-    if (input->type() != Input::Type::ObscuredShadow) {
-        assert(input->pointsToDropdownMenu());
+    if (input->pointsToDropdownMenu()) {
         std::string value = input->selectedMenuItem();
 
         int index = target->findSound(value);
@@ -119,6 +130,51 @@ void SoundBlocks::compileStopAllSounds(Compiler *compiler)
     compiler->addFunctionCall(&stopAllSounds);
 }
 
+void SoundBlocks::compileSetEffectTo(Compiler *compiler)
+{
+    compiler->addInput(VALUE);
+    int option = compiler->field(EFFECT)->specialValueId();
+
+    switch (option) {
+        case PITCH:
+            compiler->addFunctionCall(&setPitchEffectTo);
+            break;
+
+        case PAN:
+            compiler->addFunctionCall(&setPanEffectTo);
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
+}
+
+void SoundBlocks::compileChangeEffectBy(Compiler *compiler)
+{
+    compiler->addInput(VALUE);
+    int option = compiler->field(EFFECT)->specialValueId();
+
+    switch (option) {
+        case PITCH:
+            compiler->addFunctionCall(&changePitchEffectBy);
+            break;
+
+        case PAN:
+            compiler->addFunctionCall(&changePanEffectBy);
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
+}
+
+void SoundBlocks::compileClearEffects(Compiler *compiler)
+{
+    compiler->addFunctionCall(&clearEffects);
+}
+
 void SoundBlocks::compileChangeVolumeBy(Compiler *compiler)
 {
     compiler->addInput(VOLUME);
@@ -297,6 +353,46 @@ unsigned int SoundBlocks::stopAllSounds(VirtualMachine *vm)
     return 0;
 }
 
+unsigned int SoundBlocks::setPitchEffectTo(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffectValue(Sound::Effect::Pitch, vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::setPanEffectTo(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffectValue(Sound::Effect::Pan, vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::changePitchEffectBy(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffectValue(Sound::Effect::Pitch, target->soundEffectValue(Sound::Effect::Pitch) + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::changePanEffectBy(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffectValue(Sound::Effect::Pan, target->soundEffectValue(Sound::Effect::Pan) + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::clearEffects(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->clearSoundEffects();
+
+    return 0;
+}
+
 unsigned int SoundBlocks::changeVolumeBy(VirtualMachine *vm)
 {
     if (Target *target = vm->target())
diff --git a/src/blocks/soundblocks.h b/src/blocks/soundblocks.h
index 866be118..10e493c5 100644
--- a/src/blocks/soundblocks.h
+++ b/src/blocks/soundblocks.h
@@ -20,17 +20,19 @@ class SoundBlocks : public IBlockSection
         enum Inputs
         {
             SOUND_MENU,
+            VALUE,
             VOLUME
         };
 
         enum Fields
         {
-
+            EFFECT
         };
 
         enum FieldValues
         {
-
+            PITCH,
+            PAN
         };
 
         std::string name() const override;
@@ -42,6 +44,9 @@ class SoundBlocks : public IBlockSection
         static void compilePlay(Compiler *compiler);
         static void compilePlayUntilDone(Compiler *compiler);
         static void compileStopAllSounds(Compiler *compiler);
+        static void compileSetEffectTo(Compiler *compiler);
+        static void compileChangeEffectBy(Compiler *compiler);
+        static void compileClearEffects(Compiler *compiler);
         static void compileChangeVolumeBy(Compiler *compiler);
         static void compileSetVolumeTo(Compiler *compiler);
         static void compileVolume(Compiler *compiler);
@@ -62,6 +67,12 @@ class SoundBlocks : public IBlockSection
 
         static unsigned int stopAllSounds(VirtualMachine *vm);
 
+        static unsigned int setPitchEffectTo(VirtualMachine *vm);
+        static unsigned int setPanEffectTo(VirtualMachine *vm);
+        static unsigned int changePitchEffectBy(VirtualMachine *vm);
+        static unsigned int changePanEffectBy(VirtualMachine *vm);
+        static unsigned int clearEffects(VirtualMachine *vm);
+
         static unsigned int changeVolumeBy(VirtualMachine *vm);
         static unsigned int setVolumeTo(VirtualMachine *vm);
         static unsigned int volume(VirtualMachine *vm);
diff --git a/src/engine/compiler.cpp b/src/engine/compiler.cpp
index 9f737b73..2ff823ba 100644
--- a/src/engine/compiler.cpp
+++ b/src/engine/compiler.cpp
@@ -66,8 +66,10 @@ void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
 
         if (impl->block->compileFunction())
             impl->block->compile(this);
-        else
+        else {
             std::cout << "warning: unsupported block: " << impl->block->opcode() << std::endl;
+            impl->unsupportedBlocks.insert(impl->block->opcode());
+        }
 
         if (substacks != impl->substackTree.size())
             continue;
@@ -174,23 +176,27 @@ void Compiler::addInput(Input *input)
     }
     switch (input->type()) {
         case Input::Type::Shadow:
+        case Input::Type::NoShadow: {
             if (input->pointsToDropdownMenu())
                 addInstruction(OP_CONST, { impl->constIndex(input->primaryValue(), true, input->selectedMenuItem()) });
-            else
-                addInstruction(OP_CONST, { impl->constIndex(input->primaryValue()) });
-            break;
-
-        case Input::Type::NoShadow: {
-            auto previousBlock = impl->block;
-            impl->block = input->valueBlock();
-            assert(impl->block);
-            if (impl->block->compileFunction())
-                impl->block->compile(this);
             else {
-                std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
-                addInstruction(OP_NULL);
+                auto previousBlock = impl->block;
+                impl->block = input->valueBlock();
+
+                if (impl->block) {
+                    if (impl->block->compileFunction())
+                        impl->block->compile(this);
+                    else {
+                        std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                        impl->unsupportedBlocks.insert(impl->block->opcode());
+                        addInstruction(OP_NULL);
+                    }
+                } else
+                    addInstruction(OP_CONST, { impl->constIndex(input->primaryValue()) });
+
+                impl->block = previousBlock;
             }
-            impl->block = previousBlock;
+
             break;
         }
 
@@ -202,6 +208,7 @@ void Compiler::addInput(Input *input)
                     impl->block->compile(this);
                 else {
                     std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                    impl->unsupportedBlocks.insert(impl->block->opcode());
                     addInstruction(OP_NULL);
                 }
             } else
@@ -353,6 +360,12 @@ void Compiler::setProcedurePrototype(BlockPrototype *prototype)
     impl->procedurePrototype = prototype;
 }
 
+/*! Returns unsupported block opcodes which were found when compiling. */
+const std::unordered_set<std::string> &libscratchcpp::Compiler::unsupportedBlocks() const
+{
+    return impl->unsupportedBlocks;
+}
+
 /*! Returns the list of custom block prototypes. */
 const std::vector<std::string> &Compiler::procedures() const
 {
diff --git a/src/engine/compiler_p.h b/src/engine/compiler_p.h
index a310eb47..5a396a7a 100644
--- a/src/engine/compiler_p.h
+++ b/src/engine/compiler_p.h
@@ -3,6 +3,7 @@
 #pragma once
 
 #include <unordered_map>
+#include <unordered_set>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/inputvalue.h>
 
@@ -38,6 +39,8 @@ struct CompilerPrivate
         std::unordered_map<std::string, std::vector<std::string>> procedureArgs;
         BlockPrototype *procedurePrototype = nullptr;
         bool warp = false;
+
+        std::unordered_set<std::string> unsupportedBlocks;
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index d2923948..448103e4 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -26,6 +26,7 @@
 #include "blocksectioncontainer.h"
 #include "timer.h"
 #include "clock.h"
+#include "audio/iaudioengine.h"
 #include "blocks/standardblocks.h"
 #include "blocks/variableblocks.h"
 #include "blocks/listblocks.h"
@@ -34,19 +35,20 @@
 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 }, { HatType::TargetClicked, true },     { HatType::WhenGreaterThan, false }
+    { HatType::WhenTouchingObject, false }, { HatType::GreenFlag, true },   { HatType::BroadcastReceived, true }, { HatType::BackdropChanged, true },
+    { HatType::CloneInit, false },          { HatType::KeyPressed, false }, { HatType::TargetClicked, true },     { HatType::WhenGreaterThan, false }
 };
 
 const std::unordered_map<Engine::HatType, bool> Engine::m_hatEdgeActivated = {
-    { HatType::GreenFlag, false },  { HatType::BroadcastReceived, false }, { HatType::BackdropChanged, false }, { HatType::CloneInit, false },
-    { HatType::KeyPressed, false }, { HatType::TargetClicked, false },     { HatType::WhenGreaterThan, true }
+    { HatType::WhenTouchingObject, true }, { HatType::GreenFlag, false },  { HatType::BroadcastReceived, false }, { HatType::BackdropChanged, false },
+    { HatType::CloneInit, false },         { HatType::KeyPressed, false }, { HatType::TargetClicked, false },     { HatType::WhenGreaterThan, true }
 };
 
 Engine::Engine() :
     m_defaultTimer(std::make_unique<Timer>()),
     m_timer(m_defaultTimer.get()),
-    m_clock(Clock::instance().get())
+    m_clock(Clock::instance().get()),
+    m_audioEngine(IAudioEngine::instance())
 {
 }
 
@@ -80,6 +82,7 @@ void Engine::clear()
     m_scripts.clear();
     m_functions.clear();
 
+    m_whenTouchingObjectHats.clear();
     m_greenFlagHats.clear();
     m_backdropChangeHats.clear();
     m_broadcastHats.clear();
@@ -92,6 +95,8 @@ void Engine::clear()
     m_edgeActivatedHatValues.clear();
 
     m_running = false;
+
+    m_unsupportedBlocks.clear();
 }
 
 // Resolves ID references and sets pointers of entities.
@@ -102,8 +107,8 @@ void Engine::resolveIds()
         const auto &blocks = target->blocks();
         for (auto block : blocks) {
             auto container = blockSectionContainer(block->opcode());
-            block->setNext(getBlock(block->nextId()));
-            block->setParent(getBlock(block->parentId()));
+            block->setNext(getBlock(block->nextId(), target.get()));
+            block->setParent(getBlock(block->parentId(), target.get()));
 
             if (container) {
                 block->setCompileFunction(container->resolveBlockCompileFunc(block->opcode()));
@@ -112,16 +117,16 @@ void Engine::resolveIds()
 
             const auto &inputs = block->inputs();
             for (const auto &input : inputs) {
-                input->setValueBlock(getBlock(input->valueBlockId()));
+                input->setValueBlock(getBlock(input->valueBlockId(), target.get()));
 
                 if (container)
                     input->setInputId(container->resolveInput(input->name()));
 
                 InputValue *value = input->primaryValue();
                 std::string id = value->valueId(); // no reference!
-                value->setValuePtr(getEntity(id));
+                value->setValuePtr(getEntity(id, target.get()));
                 assert(input->secondaryValue()->type() != InputValue::Type::Variable && input->secondaryValue()->type() != InputValue::Type::List); // secondary values never have a variable or list
-                input->secondaryValue()->setValuePtr(getEntity(input->secondaryValue()->valueId()));
+                input->secondaryValue()->setValuePtr(getEntity(input->secondaryValue()->valueId(), target.get()));
 
                 // Add missing variables and lists
                 if (!value->valuePtr()) {
@@ -144,7 +149,7 @@ void Engine::resolveIds()
             const auto &fields = block->fields();
             for (auto field : fields) {
                 std::string id = field->valueId(); // no reference!
-                field->setValuePtr(getEntity(id));
+                field->setValuePtr(getEntity(id, target.get()));
 
                 if (container) {
                     field->setFieldId(container->resolveField(field->name()));
@@ -174,7 +179,7 @@ void Engine::resolveIds()
             block->updateInputMap();
             block->updateFieldMap();
 
-            auto comment = getComment(block->commentId());
+            auto comment = getComment(block->commentId(), target.get());
             block->setComment(comment);
 
             if (comment) {
@@ -204,7 +209,7 @@ void Engine::resolveIds()
         assert(target);
 
         for (auto field : fields) {
-            field->setValuePtr(getEntity(field->valueId()));
+            field->setValuePtr(getEntity(field->valueId(), target));
 
             if (container) {
                 field->setFieldId(container->resolveField(field->name()));
@@ -262,7 +267,7 @@ void Engine::compile()
         Compiler compiler(this, target.get());
         const auto &blocks = target->blocks();
         for (auto block : blocks) {
-            if (block->topLevel() && !block->shadow()) {
+            if (block->topLevel() && !block->isTopLevelReporter() && !block->shadow()) {
                 auto section = blockSection(block->opcode());
                 if (section) {
                     auto script = std::make_shared<Script>(target.get(), block, this);
@@ -277,8 +282,10 @@ void Engine::compile()
                         auto b = block->inputAt(block->findInput("custom_block"))->valueBlock();
                         procedureBytecodeMap[b->mutationPrototype()->procCode()] = script->bytecode();
                     }
-                } else
+                } else {
                     std::cout << "warning: unsupported top level block: " << block->opcode() << std::endl;
+                    m_unsupportedBlocks.insert(block->opcode());
+                }
             }
         }
 
@@ -295,6 +302,11 @@ void Engine::compile()
                 m_scripts[block]->setLists(compiler.lists());
             }
         }
+
+        const auto &unsupportedBlocks = compiler.unsupportedBlocks();
+
+        for (const std::string &opcode : unsupportedBlocks)
+            m_unsupportedBlocks.insert(opcode);
     }
 
     // Compile monitor blocks to bytecode
@@ -340,8 +352,15 @@ void Engine::compile()
             script->setConstValues(compiler.constValues());
             script->setVariables(compiler.variables());
             script->setLists(compiler.lists());
-        } else
+        } else {
             std::cout << "warning: unsupported monitor block: " << block->opcode() << std::endl;
+            m_unsupportedBlocks.insert(block->opcode());
+        }
+
+        const auto &unsupportedBlocks = compiler.unsupportedBlocks();
+
+        for (const std::string &opcode : unsupportedBlocks)
+            m_unsupportedBlocks.insert(opcode);
     }
 }
 
@@ -363,15 +382,33 @@ void Engine::start()
 void Engine::stop()
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L2057-L2081
-    deleteClones();
-    stopSounds();
-
     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;
+
+        // Remove threads owned by clones because clones are going to be deleted (#547)
+        m_threads.erase(
+            std::remove_if(
+                m_threads.begin(),
+                m_threads.end(),
+                [](std::shared_ptr<VirtualMachine> thread) {
+                    assert(thread);
+                    Target *target = thread->target();
+                    assert(target);
+
+                    if (!target->isStage()) {
+                        Sprite *sprite = static_cast<Sprite *>(target);
+
+                        if (sprite->isClone())
+                            return true;
+                    }
+
+                    return false;
+                }),
+            m_threads.end());
     } 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
@@ -383,6 +420,10 @@ void Engine::stop()
         m_threads.clear();
         m_running = false;
     }
+
+    deleteClones();
+    stopSounds();
+    m_stopped();
 }
 
 VirtualMachine *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target *target)
@@ -390,7 +431,7 @@ VirtualMachine *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target
     return pushThread(topLevelBlock, target).get();
 }
 
-void Engine::broadcast(unsigned int index)
+void Engine::broadcast(int index)
 {
     if (index < 0 || index >= m_broadcasts.size())
         return;
@@ -459,17 +500,24 @@ void Engine::deinitClone(std::shared_ptr<Sprite> clone)
 
 void Engine::stopSounds()
 {
-    // TODO: Loop through clones
     for (auto target : m_targets) {
         const auto &sounds = target->sounds();
 
-        for (auto sound : sounds) {
-            if (sound->isPlaying())
-                sound->stop();
-        }
+        for (auto sound : sounds)
+            sound->stop();
     }
 }
 
+double Engine::globalVolume() const
+{
+    return m_audioEngine->volume() * 100;
+}
+
+void Engine::setGlobalVolume(double volume)
+{
+    m_audioEngine->setVolume(volume / 100);
+}
+
 void Engine::updateMonitors()
 {
     // Execute the "script" of each visible monitor
@@ -505,24 +553,24 @@ void Engine::step()
                 bool oldValue = false;
                 auto hatBlock = thread->script()->topBlock();
                 assert(hatBlock);
-                assert(hatBlock->fieldAt(0)); // TODO: Edge-activated hats currently support only one field
-                int fieldValueId = hatBlock->fieldAt(0)->specialValueId();
-                assert(fieldValueId != -1);
-                auto it = m_edgeActivatedHatValues.find(hatType);
+
+                Target *target = hatBlock->target();
+                assert(target);
+                auto it = m_edgeActivatedHatValues.find(hatBlock.get());
 
                 if (it == m_edgeActivatedHatValues.cend()) {
-                    m_edgeActivatedHatValues[hatType] = {};
+                    m_edgeActivatedHatValues[hatBlock.get()] = {};
                 } else {
-                    const std::unordered_map<int, bool> &values = it->second;
-                    auto fieldIt = values.find(fieldValueId);
+                    auto &map = it->second;
+                    auto it = map.find(target);
 
-                    if (fieldIt != values.cend())
-                        oldValue = fieldIt->second;
+                    if (it != map.cend())
+                        oldValue = it->second;
                 }
 
-                bool newValue = thread->script()->runHatPredicate();
+                bool newValue = thread->script()->runHatPredicate(hatBlock->target());
                 bool edgeWasActivated = !oldValue && newValue; // changed from false true
-                m_edgeActivatedHatValues[hatType][fieldValueId] = newValue;
+                m_edgeActivatedHatValues[hatBlock.get()][target] = newValue;
 
                 if (!edgeWasActivated)
                     stopThread(thread.get());
@@ -568,6 +616,11 @@ sigslot::signal<VirtualMachine *> &Engine::threadAboutToStop()
     return m_threadAboutToStop;
 }
 
+sigslot::signal<> &Engine::stopped()
+{
+    return m_stopped;
+}
+
 std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L70-L173
@@ -778,7 +831,7 @@ double Engine::mouseX() const
 
 void Engine::setMouseX(double x)
 {
-    m_mouseX = x;
+    m_mouseX = std::round(x);
 }
 
 double Engine::mouseY() const
@@ -788,7 +841,7 @@ double Engine::mouseY() const
 
 void Engine::setMouseY(double y)
 {
-    m_mouseY = y;
+    m_mouseY = std::round(y);
 }
 
 bool Engine::mousePressed() const
@@ -1044,14 +1097,21 @@ std::shared_ptr<Broadcast> Engine::broadcastAt(int index) const
     return m_broadcasts[index];
 }
 
-int Engine::findBroadcast(const std::string &broadcastName) const
+std::vector<int> Engine::findBroadcasts(const std::string &broadcastName) const
 {
-    auto it = std::find_if(m_broadcasts.begin(), m_broadcasts.end(), [broadcastName](std::shared_ptr<Broadcast> broadcast) { return broadcast->name() == broadcastName; });
+    std::vector<int> ret;
+    std::string lowercaseName = broadcastName;
+    std::transform(lowercaseName.begin(), lowercaseName.end(), lowercaseName.begin(), ::tolower);
 
-    if (it == m_broadcasts.end())
-        return -1;
-    else
-        return it - m_broadcasts.begin();
+    for (unsigned int i = 0; i < m_broadcasts.size(); i++) {
+        std::string name = m_broadcasts[i]->name();
+        std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+
+        if (name == lowercaseName)
+            ret.push_back(i);
+    }
+
+    return ret;
 }
 
 int Engine::findBroadcastById(const std::string &broadcastId) const
@@ -1064,6 +1124,11 @@ int Engine::findBroadcastById(const std::string &broadcastId) const
         return it - m_broadcasts.begin();
 }
 
+void Engine::addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock)
+{
+    addHatToMap(m_whenTouchingObjectHats, m_scripts[hatBlock].get());
+}
+
 void Engine::addGreenFlagScript(std::shared_ptr<Block> hatBlock)
 {
     addHatToMap(m_greenFlagHats, m_scripts[hatBlock].get());
@@ -1307,6 +1372,11 @@ sigslot::signal<const std::string &> &Engine::questionAsked()
     return m_questionAsked;
 }
 
+sigslot::signal<> &Engine::questionAborted()
+{
+    return m_questionAborted;
+}
+
 sigslot::signal<const std::string &> &Engine::questionAnswered()
 {
     return m_questionAnswered;
@@ -1341,47 +1411,99 @@ const std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> &Engin
 }
 
 // Returns the block with the given ID.
-std::shared_ptr<Block> Engine::getBlock(const std::string &id)
+std::shared_ptr<Block> Engine::getBlock(const std::string &id, Target *target)
 {
     if (id.empty())
         return nullptr;
 
-    for (auto target : m_targets) {
-        int index = target->findBlock(id);
+    int index;
+
+    if (target) {
+        index = target->findBlock(id);
+
         if (index != -1)
             return target->blockAt(index);
     }
 
+    for (auto t : m_targets) {
+        index = t->findBlock(id);
+
+        if (index != -1)
+            return t->blockAt(index);
+    }
+
     return nullptr;
 }
 
 // Returns the variable with the given ID.
-std::shared_ptr<Variable> Engine::getVariable(const std::string &id)
+std::shared_ptr<Variable> Engine::getVariable(const std::string &id, Target *target)
 {
     if (id.empty())
         return nullptr;
 
-    for (auto target : m_targets) {
-        int index = target->findVariableById(id);
+    Stage *stage = this->stage();
+    int index;
+
+    // Check stage
+    index = stage->findVariableById(id);
+
+    if (index != -1)
+        return stage->variableAt(index);
+
+    // Check currently compiled target
+    if (target != stage) {
+        index = target->findVariableById(id);
+
         if (index != -1)
             return target->variableAt(index);
     }
 
+    // Fall back to checking all the other targets
+    for (auto t : m_targets) {
+        if (t.get() != stage && t.get() != target) {
+            int index = t->findVariableById(id);
+
+            if (index != -1)
+                return t->variableAt(index);
+        }
+    }
+
     return nullptr;
 }
 
 // Returns the Scratch list with the given ID.
-std::shared_ptr<List> Engine::getList(const std::string &id)
+std::shared_ptr<List> Engine::getList(const std::string &id, Target *target)
 {
     if (id.empty())
         return nullptr;
 
-    for (auto target : m_targets) {
-        int index = target->findListById(id);
+    Stage *stage = this->stage();
+    int index;
+
+    // Check stage
+    index = stage->findListById(id);
+
+    if (index != -1)
+        return stage->listAt(index);
+
+    // Check currently compiled target
+    if (target != stage) {
+        index = target->findListById(id);
+
         if (index != -1)
             return target->listAt(index);
     }
 
+    // Fall back to checking all the other targets
+    for (auto t : m_targets) {
+        if (t.get() != stage && t.get() != target) {
+            int index = t->findListById(id);
+
+            if (index != -1)
+                return t->listAt(index);
+        }
+    }
+
     return nullptr;
 }
 
@@ -1399,35 +1521,40 @@ std::shared_ptr<Broadcast> Engine::getBroadcast(const std::string &id)
 }
 
 // Returns the comment with the given ID.
-std::shared_ptr<Comment> Engine::getComment(const std::string &id)
+std::shared_ptr<Comment> Engine::getComment(const std::string &id, Target *target)
 {
     if (id.empty())
         return nullptr;
 
-    for (auto target : m_targets) {
-        int index = target->findComment(id);
+    int index;
+
+    if (target) {
+        index = target->findComment(id);
+
         if (index != -1)
             return target->commentAt(index);
     }
 
+    for (auto t : m_targets) {
+        index = t->findComment(id);
+
+        if (index != -1)
+            return t->commentAt(index);
+    }
+
     return nullptr;
 }
 
 // Returns the entity with the given ID. \see IEntity
-std::shared_ptr<Entity> Engine::getEntity(const std::string &id)
+std::shared_ptr<Entity> Engine::getEntity(const std::string &id, Target *target)
 {
-    // Blocks
-    auto block = getBlock(id);
-    if (block)
-        return std::static_pointer_cast<Entity>(block);
-
     // Variables
-    auto variable = getVariable(id);
+    auto variable = getVariable(id, target);
     if (variable)
         return std::static_pointer_cast<Entity>(variable);
 
     // Lists
-    auto list = getList(id);
+    auto list = getList(id, target);
     if (list)
         return std::static_pointer_cast<Entity>(list);
 
@@ -1436,6 +1563,16 @@ std::shared_ptr<Entity> Engine::getEntity(const std::string &id)
     if (broadcast)
         return std::static_pointer_cast<Entity>(broadcast);
 
+    // Blocks
+    auto block = getBlock(id, target);
+    if (block)
+        return std::static_pointer_cast<Entity>(block);
+
+    // Comments
+    auto comment = getComment(id, target);
+    if (comment)
+        return std::static_pointer_cast<Entity>(comment);
+
     return nullptr;
 }
 
@@ -1495,6 +1632,9 @@ const std::vector<Script *> &Engine::getHats(Target *target, HatType type)
     }
 
     switch (type) {
+        case HatType::WhenTouchingObject:
+            return m_whenTouchingObjectHats[target];
+
         case HatType::GreenFlag:
             return m_greenFlagHats[target];
 
@@ -1565,6 +1705,11 @@ void Engine::setUserAgent(const std::string &agent)
     m_userAgent = agent;
 }
 
+const std::unordered_set<std::string> &Engine::unsupportedBlocks() const
+{
+    return m_unsupportedBlocks;
+}
+
 void Engine::finalize()
 {
     m_eventLoopMutex.lock();
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 69b05dd6..218dc9ba 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -19,6 +19,7 @@ namespace libscratchcpp
 
 class Entity;
 class IClock;
+class IAudioEngine;
 
 class Engine : public IEngine
 {
@@ -34,14 +35,17 @@ 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) override;
+        void broadcast(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;
         void deinitClone(std::shared_ptr<Sprite> clone) override;
+
         void stopSounds() override;
+        virtual double globalVolume() const override;
+        virtual void setGlobalVolume(double volume) override;
 
         void updateMonitors() override;
         void step() override;
@@ -51,6 +55,7 @@ class Engine : public IEngine
 
         sigslot::signal<> &aboutToRender() override;
         sigslot::signal<VirtualMachine *> &threadAboutToStop() override;
+        sigslot::signal<> &stopped() override;
 
         bool isRunning() const override;
 
@@ -118,9 +123,10 @@ class Engine : public IEngine
         const std::vector<std::shared_ptr<Broadcast>> &broadcasts() const override;
         void setBroadcasts(const std::vector<std::shared_ptr<Broadcast>> &broadcasts) override;
         std::shared_ptr<Broadcast> broadcastAt(int index) const override;
-        int findBroadcast(const std::string &broadcastName) const override;
+        std::vector<int> findBroadcasts(const std::string &broadcastName) const override;
         int findBroadcastById(const std::string &broadcastId) const override;
 
+        void addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock) 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;
@@ -148,6 +154,7 @@ class Engine : public IEngine
         sigslot::signal<Monitor *, IMonitorHandler *> &monitorRemoved() override;
 
         sigslot::signal<const std::string &> &questionAsked() override;
+        sigslot::signal<> &questionAborted() override;
         sigslot::signal<const std::string &> &questionAnswered() override;
 
         const std::vector<std::string> &extensions() const override;
@@ -161,11 +168,15 @@ class Engine : public IEngine
         const std::string &userAgent() const override;
         void setUserAgent(const std::string &agent) override;
 
+        const std::unordered_set<std::string> &unsupportedBlocks() const override;
+
         IClock *m_clock = nullptr;
+        IAudioEngine *m_audioEngine = nullptr;
 
     private:
         enum class HatType
         {
+            WhenTouchingObject,
             GreenFlag,
             BroadcastReceived,
             BackdropChanged,
@@ -191,12 +202,12 @@ class Engine : public IEngine
         void removeExecutableClones();
         void createMissingMonitors();
         void addVarOrListMonitor(std::shared_ptr<Monitor> monitor, Target *target);
-        std::shared_ptr<Block> getBlock(const std::string &id);
-        std::shared_ptr<Variable> getVariable(const std::string &id);
-        std::shared_ptr<List> getList(const std::string &id);
+        std::shared_ptr<Block> getBlock(const std::string &id, Target *target);
+        std::shared_ptr<Variable> getVariable(const std::string &id, Target *target);
+        std::shared_ptr<List> getList(const std::string &id, Target *target);
         std::shared_ptr<Broadcast> getBroadcast(const std::string &id);
-        std::shared_ptr<Comment> getComment(const std::string &id);
-        std::shared_ptr<Entity> getEntity(const std::string &id);
+        std::shared_ptr<Comment> getComment(const std::string &id, Target *target);
+        std::shared_ptr<Entity> getEntity(const std::string &id, Target *target);
         std::shared_ptr<IBlockSection> blockSection(const std::string &opcode) const;
 
         void addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script);
@@ -236,6 +247,7 @@ class Engine : public IEngine
         std::recursive_mutex m_eventLoopMutex;
         std::string m_userAgent;
 
+        std::unordered_map<Target *, std::vector<Script *>> m_whenTouchingObjectHats;
         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;
@@ -246,7 +258,7 @@ class Engine : public IEngine
 
         std::unordered_map<Script *, std::unordered_map<HatField, int>> m_scriptHatFields; // HatField, field ID from the block implementation
 
-        std::unordered_map<HatType, std::unordered_map<int, bool>> m_edgeActivatedHatValues; // (field value, last value) edge-activated hats only run after the value changes from false to true
+        std::unordered_map<Block *, std::unordered_map<Target *, bool>> m_edgeActivatedHatValues; // (block, target, last value) edge-activated hats only run after the value changes from false to true
 
         std::unique_ptr<ITimer> m_defaultTimer;
         ITimer *m_timer = nullptr;
@@ -268,13 +280,17 @@ class Engine : public IEngine
         bool m_redrawRequested = false;
         sigslot::signal<> m_aboutToRedraw;
         sigslot::signal<VirtualMachine *> m_threadAboutToStop;
+        sigslot::signal<> m_stopped;
         bool m_stopEventLoop = false;
         std::mutex m_stopEventLoopMutex;
 
         sigslot::signal<Monitor *> m_monitorAdded;
         sigslot::signal<Monitor *, IMonitorHandler *> m_monitorRemoved;
         sigslot::signal<const std::string &> m_questionAsked;
+        sigslot::signal<> m_questionAborted;
         sigslot::signal<const std::string &> m_questionAnswered;
+
+        std::unordered_set<std::string> m_unsupportedBlocks;
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index d544b5b8..2dfd39a7 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -53,29 +53,28 @@ void Script::setBytecode(const std::vector<unsigned int> &code)
 void Script::setHatPredicateBytecode(const std::vector<unsigned int> &code)
 {
     impl->hatPredicateBytecodeVector = code;
-
-    if (impl->engine && !code.empty()) {
-        impl->hatPredicateVm = std::make_shared<VirtualMachine>(impl->engine->stage(), impl->engine, this);
-        impl->hatPredicateVm->setBytecode(impl->hatPredicateBytecodeVector.data());
-        impl->hatPredicateVm->setConstValues(impl->constValues);
-    }
 }
 
 /*!
- * Runs the edge-activated hat predicate and returns the reported value.
+ * Runs the edge-activated hat predicate as the given target and returns the reported value.
  * \note If there isn't any predicate, nothing will happen and the returned value will be false.
  */
-bool Script::runHatPredicate()
+bool Script::runHatPredicate(Target *target)
 {
-    if (impl->hatPredicateVm && impl->hatPredicateVm->bytecode()) {
-        impl->hatPredicateVm->reset();
-        impl->hatPredicateVm->setFunctions(getFunctions());
-        impl->hatPredicateVm->run();
-        assert(impl->hatPredicateVm->registerCount() == 1);
-
-        if (impl->hatPredicateVm->registerCount() == 1)
-            return impl->hatPredicateVm->getInput(0, 1)->toBool();
-    }
+    if (!target || !impl->engine || impl->hatPredicateBytecodeVector.empty())
+        return false;
+
+    auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
+    vm->setBytecode(impl->hatPredicateBytecodeVector.data());
+    vm->setConstValues(impl->constValues);
+    vm->setFunctions(getFunctions());
+    vm->setVariables(impl->variableValues.data());
+    vm->setLists(impl->lists.data());
+    vm->run();
+    assert(vm->registerCount() == 1);
+
+    if (vm->registerCount() == 1)
+        return vm->getInput(0, 1)->toBool();
 
     return false;
 }
@@ -161,9 +160,6 @@ void Script::setConstValues(const std::vector<Value> &values)
 {
     impl->constValuesVector = values;
     impl->constValues = impl->constValuesVector.data();
-
-    if (impl->hatPredicateVm)
-        impl->hatPredicateVm->setConstValues(impl->constValues);
 }
 
 /*! Sets the list of variables. */
diff --git a/src/engine/script_p.h b/src/engine/script_p.h
index d3f991a4..6d029160 100644
--- a/src/engine/script_p.h
+++ b/src/engine/script_p.h
@@ -22,9 +22,7 @@ struct ScriptPrivate
 
         unsigned int *bytecode = nullptr;
         std::vector<unsigned int> bytecodeVector;
-
         std::vector<unsigned int> hatPredicateBytecodeVector;
-        std::shared_ptr<VirtualMachine> hatPredicateVm;
 
         Target *target = nullptr;
         std::shared_ptr<Block> topBlock;
diff --git a/src/engine/virtualmachine_p.cpp b/src/engine/virtualmachine_p.cpp
index b9a99521..6f2c0e4f 100644
--- a/src/engine/virtualmachine_p.cpp
+++ b/src/engine/virtualmachine_p.cpp
@@ -6,6 +6,7 @@
 #include <scratchcpp/list.h>
 #include <iostream>
 #include <cassert>
+#include <utf8.h>
 
 #include "virtualmachine_p.h"
 #include "internal/randomgenerator.h"
@@ -764,8 +765,14 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     DISPATCH();
 
     OP(STR_CONTAINS) :
-        REPLACE_RET_VALUE(READ_REG(0, 2)->toUtf16().find(READ_REG(1, 2)->toUtf16()) != std::u16string::npos, 2);
-    FREE_REGS(1);
+    {
+        std::u16string string1 = READ_REG(0, 2)->toUtf16();
+        std::u16string string2 = READ_REG(1, 2)->toUtf16();
+        std::transform(string1.begin(), string1.end(), string1.begin(), ::tolower);
+        std::transform(string2.begin(), string2.end(), string2.begin(), ::tolower);
+        REPLACE_RET_VALUE(string1.find(string2) != std::u16string::npos, 2);
+        FREE_REGS(1);
+    }
     DISPATCH();
 
     OP(EXEC) :
diff --git a/src/internal/projectdownloader.cpp b/src/internal/projectdownloader.cpp
index 15e31246..c334da55 100644
--- a/src/internal/projectdownloader.cpp
+++ b/src/internal/projectdownloader.cpp
@@ -94,10 +94,8 @@ bool ProjectDownloader::downloadAssets(const std::vector<std::string> &assetIds)
     m_cancelMutex.unlock();
 
     auto count = assetIds.size();
-    unsigned int threadCount = std::thread::hardware_concurrency();
-
-    // Thread count: number of assets / 5, limited to maximum number of threads
-    threadCount = std::max(1u, std::min(threadCount, static_cast<unsigned int>(std::ceil(count / 5.0))));
+    // unsigned int threadCount = std::thread::hardware_concurrency();
+    unsigned int threadCount = 20;
 
     m_assets.clear();
     m_assets.reserve(count);
@@ -120,48 +118,92 @@ bool ProjectDownloader::downloadAssets(const std::vector<std::string> &assetIds)
         downloaders.push_back(m_downloaderFactory->create());
 
     // Download assets
-    auto f = [this, &downloaders, &assetIds, count, threadCount](unsigned int thread) {
-        auto downloader = downloaders[thread];
-        unsigned int n = std::ceil(count / static_cast<double>(threadCount));
+    auto f = [this, count](std::shared_ptr<IDownloader> downloader, int index, const std::string &id) {
+        m_cancelMutex.lock();
 
-        for (unsigned int i = 0; i < n; i++) {
-            unsigned int index = thread * n + i;
+        if (m_cancel)
+            return;
 
-            if (index < count) {
-                m_cancelMutex.lock();
+        m_cancelMutex.unlock();
 
-                if (m_cancel)
-                    return;
+        bool ret = downloader->download(ASSET_PREFIX + id + ASSET_SUFFIX);
 
-                m_cancelMutex.unlock();
+        if (!ret) {
+            std::cerr << "Failed to download asset: " << id << std::endl;
+            m_cancelMutex.lock();
+            m_cancel = true;
+            m_cancelMutex.unlock();
+            return;
+        }
 
-                bool ret = downloader->download(ASSET_PREFIX + assetIds[index] + ASSET_SUFFIX);
+        m_assetsMutex.lock();
+        m_assets[index] = downloader->text();
+        m_downloadedAssetCount++;
+        m_downloadProgressChanged(m_downloadedAssetCount, count);
+        m_assetsMutex.unlock();
+    };
 
-                if (!ret) {
-                    std::cerr << "Failed to download asset: " << assetIds[index] << std::endl;
-                    m_cancelMutex.lock();
-                    m_cancel = true;
-                    m_cancelMutex.unlock();
-                    return;
-                }
+    std::unordered_map<int, std::pair<std::thread, std::shared_ptr<IDownloader>>> threads;
+    bool done = false;
+    unsigned int lastCount = 0, i = 0;
 
-                m_assetsMutex.lock();
-                m_assets[index] = downloader->text();
-                m_downloadedAssetCount++;
-                std::cout << "Downloaded assets: " << m_downloadedAssetCount << " of " << count << std::endl;
-                m_downloadProgressChanged(m_downloadedAssetCount, count);
-                m_assetsMutex.unlock();
+    while (true) {
+        int addCount = threadCount - threads.size();
+
+        for (int j = 0; j < addCount; j++) {
+            if (i >= count) {
+                done = true;
+                break;
             }
+
+            std::shared_ptr<IDownloader> freeDownloader = nullptr;
+
+            for (auto downloader : downloaders) {
+                auto it = std::find_if(threads.begin(), threads.end(), [&downloader](std::pair<const int, std::pair<std::thread, std::shared_ptr<IDownloader>>> &pair) {
+                    return pair.second.second == downloader;
+                });
+
+                if (it == threads.cend()) {
+                    freeDownloader = downloader;
+                    break;
+                }
+            }
+
+            assert(freeDownloader);
+            threads[i] = { std::thread(f, freeDownloader, i, assetIds[i]), freeDownloader };
+            i++;
         }
-    };
 
-    std::vector<std::thread> threads;
+        std::this_thread::sleep_for(std::chrono::milliseconds(25));
 
-    for (unsigned int i = 0; i < threadCount; i++)
-        threads.emplace_back(std::thread(f, i));
+        m_assetsMutex.lock();
 
-    for (unsigned int i = 0; i < threadCount; i++)
-        threads[i].join();
+        if (m_downloadedAssetCount != lastCount) {
+            std::cout << "Downloaded assets: " << m_downloadedAssetCount << " of " << count << std::endl;
+            lastCount = m_downloadedAssetCount;
+        }
+
+        std::vector<int> toRemove;
+
+        for (auto &[index, info] : threads) {
+            if (!m_assets[index].empty())
+                toRemove.push_back(index);
+        }
+
+        m_assetsMutex.unlock();
+
+        for (int index : toRemove) {
+            threads[index].first.join();
+            threads.erase(index);
+        }
+
+        if (done) {
+            for (auto &[index, info] : threads)
+                info.first.join();
+
+            break;
+        }
+    }
 
     CHECK_CANCEL();
 
diff --git a/src/internal/scratch3reader.cpp b/src/internal/scratch3reader.cpp
index 14f6065b..203cf9b6 100644
--- a/src/internal/scratch3reader.cpp
+++ b/src/internal/scratch3reader.cpp
@@ -92,6 +92,11 @@ bool Scratch3Reader::load()
                     reporterInfo->setValueId(jsonToValue(blockInfo[2]).toString());
                     reporterInfo->setType(static_cast<InputValue::Type>(blockInfo[0]));
 
+                    if (blockInfo.size() > 3) {
+                        block->setX(blockInfo[3]);
+                        block->setY(blockInfo[4]);
+                    }
+
                     target->addBlock(block);
                     continue;
                 }
@@ -108,6 +113,19 @@ bool Scratch3Reader::load()
                 if (!blockInfo["parent"].is_null())
                     parentId = blockInfo["parent"];
                 block->setParentId(parentId);
+                READER_STEP(step, "target -> block -> parent");
+                if (!blockInfo["parent"].is_null())
+                    parentId = blockInfo["parent"];
+                block->setParentId(parentId);
+
+                if (block->topLevel()) {
+                    READER_STEP(step, "target -> block -> x");
+                    if (!blockInfo["x"].is_null())
+                        block->setX(blockInfo["x"]);
+                    READER_STEP(step, "target -> block -> y");
+                    if (!blockInfo["y"].is_null())
+                        block->setY(blockInfo["y"]);
+                }
 
                 // inputs
                 READER_STEP(step, "target -> block -> inputs");
@@ -544,7 +562,9 @@ void Scratch3Reader::read()
     if (m_zipReader->open()) {
         // Parse the JSON
         try {
-            m_json = json::parse(m_zipReader->readFileToString("project.json"));
+            std::string jsonStr;
+            m_zipReader->readFileToString("project.json", jsonStr);
+            m_json = json::parse(jsonStr);
         } catch (std::exception &e) {
             printErr("invalid JSON file", e.what());
         }
diff --git a/src/internal/zipreader.cpp b/src/internal/zipreader.cpp
index ae0358b0..fd8a48db 100644
--- a/src/internal/zipreader.cpp
+++ b/src/internal/zipreader.cpp
@@ -48,17 +48,14 @@ size_t ZipReader::readFile(const std::string &fileName, void **buf)
     return bufsize;
 }
 
-std::string ZipReader::readFileToString(const std::string &fileName)
+void ZipReader::readFileToString(const std::string &fileName, std::string &dst)
 {
     void *buf = nullptr;
     size_t bufsize = readFile(fileName, &buf);
 
     if (buf) {
-        std::string ret(reinterpret_cast<char *>(buf), bufsize);
+        dst.assign(reinterpret_cast<char *>(buf), bufsize);
         free(buf);
-
-        return ret;
-    }
-
-    return "";
+    } else
+        dst = "";
 }
diff --git a/src/internal/zipreader.h b/src/internal/zipreader.h
index 9c9db512..546aec69 100644
--- a/src/internal/zipreader.h
+++ b/src/internal/zipreader.h
@@ -20,7 +20,7 @@ class ZipReader
         void close();
 
         size_t readFile(const std::string &fileName, void **buf);
-        std::string readFileToString(const std::string &fileName);
+        void readFileToString(const std::string &fileName, std::string &dst);
 
     private:
         std::string m_fileName;
diff --git a/src/project.cpp b/src/project.cpp
index b5d94afe..221d8f1a 100644
--- a/src/project.cpp
+++ b/src/project.cpp
@@ -21,15 +21,6 @@ Project::Project(const std::string &fileName) :
 {
 }
 
-/*!
- * Constructs ScratchProjects with the given file name, for the given Scratch version.
- * \note You shouldn't normally use this constructor because the Scratch version is determined automatically.
- */
-Project::Project(const std::string &fileName, ScratchVersion scratchVersion) :
-    impl(spimpl::make_unique_impl<ProjectPrivate>(fileName, scratchVersion))
-{
-}
-
 /*! Loads the project. Returns true if successful. */
 bool Project::load()
 {
@@ -75,22 +66,6 @@ const std::string &Project::fileName() const
 void Project::setFileName(const std::string &newFileName)
 {
     impl->fileName = newFileName;
-    impl->detectScratchVersion();
-}
-
-/*! Returns the version of Scratch used for the project. */
-ScratchVersion Project::scratchVersion() const
-{
-    return impl->scratchVersion;
-}
-
-/*!
- * Sets the version of Scratch.
- * \note You shouldn't use this as the Scratch version is automatically determined.
- */
-void Project::setScratchVersion(const ScratchVersion &version)
-{
-    impl->setScratchVersion(version);
 }
 
 /*! Returns the engine of the loaded project. \see IEngine */
diff --git a/src/project_p.cpp b/src/project_p.cpp
index 951c3f3f..e3450fb4 100644
--- a/src/project_p.cpp
+++ b/src/project_p.cpp
@@ -25,33 +25,28 @@ ProjectPrivate::ProjectPrivate() :
 }
 
 ProjectPrivate::ProjectPrivate(const std::string &fileName) :
-    ProjectPrivate()
-{
-    this->fileName = fileName;
-
-    // Auto detect Scratch version
-    detectScratchVersion();
-}
-
-ProjectPrivate::ProjectPrivate(const std::string &fileName, ScratchVersion scratchVersion) :
     fileName(fileName),
     engine(std::make_shared<Engine>())
 {
-    setScratchVersion(scratchVersion);
+    this->fileName = fileName;
 }
 
 bool ProjectPrivate::load()
 {
     std::shared_ptr<IProjectReader> reader;
-    switch (scratchVersion) {
-        case ScratchVersion::Invalid:
-            std::cerr << "Could not read the project because version is set to invalid." << std::endl;
-            return false;
-        case ScratchVersion::Scratch3:
-            reader = std::make_shared<Scratch3Reader>();
-            break;
-    }
 
+    // Scratch 3
+    reader = std::make_shared<Scratch3Reader>();
+
+    if (tryLoad(reader.get()))
+        return true;
+
+    std::cerr << "Unsupported Scratch version." << std::endl;
+    return false;
+}
+
+bool ProjectPrivate::tryLoad(IProjectReader *reader)
+{
     // Load from URL
     ProjectUrl url(fileName);
 
@@ -114,7 +109,6 @@ bool ProjectPrivate::load()
         // Load from file
         reader->setFileName(fileName);
         if (!reader->isValid()) {
-            scratchVersion = ScratchVersion::Invalid;
             std::cerr << "Could not read the project." << std::endl;
             return false;
         }
@@ -149,40 +143,6 @@ void ProjectPrivate::runEventLoop()
     engine->runEventLoop();
 }
 
-void ProjectPrivate::detectScratchVersion()
-{
-    ProjectUrl url(fileName);
-
-    scratchVersion = ScratchVersion::Invalid;
-    Scratch3Reader scratch3;
-
-    if (url.isProjectUrl()) {
-        if (!downloader->downloadJson(url.projectId())) {
-            std::cerr << "Failed to download the project file." << std::endl;
-            return;
-        }
-
-        scratch3.loadData(downloader->json());
-    } else
-        scratch3.setFileName(fileName);
-
-    if (scratch3.isValid())
-        scratchVersion = ScratchVersion::Scratch3;
-
-    if (scratchVersion == ScratchVersion::Invalid)
-        std::cerr << "Unable to determine Scratch version." << std::endl;
-}
-
-void ProjectPrivate::setScratchVersion(ScratchVersion version)
-{
-    // TODO: Use this when more versions become supported
-    // if((version >= Version::Scratch3) && (version <= Version::Scratch3))
-    if (version == ScratchVersion::Scratch3)
-        scratchVersion = version;
-    else
-        std::cerr << "Unsupported Scratch version: " << static_cast<int>(version) << std::endl;
-}
-
 sigslot::signal<unsigned int, unsigned int> &ProjectPrivate::downloadProgressChanged()
 {
     return downloader->downloadProgressChanged();
diff --git a/src/project_p.h b/src/project_p.h
index 6ccabfff..d935835c 100644
--- a/src/project_p.h
+++ b/src/project_p.h
@@ -9,6 +9,7 @@ namespace libscratchcpp
 {
 
 class IEngine;
+class IProjectReader;
 class IProjectDownloaderFactory;
 class IProjectDownloader;
 
@@ -16,21 +17,17 @@ struct ProjectPrivate
 {
         ProjectPrivate();
         ProjectPrivate(const std::string &fileName);
-        ProjectPrivate(const std::string &fileName, ScratchVersion scratchVersion);
         ProjectPrivate(const ProjectPrivate &) = delete;
 
         bool load();
+        bool tryLoad(IProjectReader *reader);
 
         void start();
         void run();
         void runEventLoop();
 
-        void detectScratchVersion();
-        void setScratchVersion(ScratchVersion version);
-
         sigslot::signal<unsigned int, unsigned int> &downloadProgressChanged();
 
-        ScratchVersion scratchVersion = ScratchVersion::Invalid;
         std::string fileName;
         std::shared_ptr<IEngine> engine = nullptr;
 
diff --git a/src/scratch/CMakeLists.txt b/src/scratch/CMakeLists.txt
index 7d2d47e4..d317335a 100644
--- a/src/scratch/CMakeLists.txt
+++ b/src/scratch/CMakeLists.txt
@@ -1,5 +1,6 @@
 target_sources(scratchcpp
   PRIVATE
+    value.cpp
     target.cpp
     target_p.cpp
     target_p.h
diff --git a/src/scratch/block.cpp b/src/scratch/block.cpp
index 6ce51593..0350ccd4 100644
--- a/src/scratch/block.cpp
+++ b/src/scratch/block.cpp
@@ -313,6 +313,36 @@ bool Block::topLevel() const
     return (impl->parentId == "" && !impl->parent);
 }
 
+/*! Returns the X-coordinate of the block in the code area (only for top level blocks). */
+int Block::x() const
+{
+    return impl->x;
+}
+
+/*! Sets the X-coordinate of the block in the code area (only for top level blocks). */
+void Block::setX(int x)
+{
+    if (!topLevel())
+        std::cout << "warning: setting X-coordinate of a block which is not a top level block" << std::endl;
+
+    impl->x = x;
+}
+
+/*! Returns the Y-coordinate of the block in the code area (only for top level blocks). */
+int Block::y() const
+{
+    return impl->y;
+}
+
+/*! Sets the Y-coordinate of the block in the code area (only for top level blocks). */
+void Block::setY(int y)
+{
+    if (!topLevel())
+        std::cout << "warning: setting Y-coordinate of a block which is not a top level block" << std::endl;
+
+    impl->y = y;
+}
+
 /*! Returns the comment which is attached to this block. */
 std::shared_ptr<Comment> Block::comment() const
 {
diff --git a/src/scratch/block_p.h b/src/scratch/block_p.h
index 215d3bbd..a1aecb7b 100644
--- a/src/scratch/block_p.h
+++ b/src/scratch/block_p.h
@@ -33,6 +33,8 @@ struct BlockPrivate
         std::vector<std::shared_ptr<Field>> fields;
         std::unordered_map<int, Field *> fieldMap;
         bool shadow = false;
+        int x = 0;
+        int y = 0;
         std::string commentId;
         std::shared_ptr<Comment> comment = nullptr;
         IEngine *engine = nullptr;
diff --git a/src/scratch/input.cpp b/src/scratch/input.cpp
index 2e2e16c8..30de8fed 100644
--- a/src/scratch/input.cpp
+++ b/src/scratch/input.cpp
@@ -98,13 +98,13 @@ void Input::setValueBlockId(const std::string &id)
 
 /*!
  * Returns true if the input points to a dropdown menu.\n
- * (if type() == Type::Shadow and valueBlock() points to a block with a single field which does not point to an entity)
+ * (if valueBlock() points to a shadow block with a single field which does not point to an entity)
  */
 bool Input::pointsToDropdownMenu() const
 {
     auto block = valueBlock();
 
-    if ((impl->type != Type::Shadow) || !block)
+    if (!block || !block->shadow())
         return false;
 
     const auto &fields = block->fields();
diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index 295626b2..e4270b72 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -1,12 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/sound.h>
+#include <scratchcpp/sprite.h>
 #include <iostream>
+#include <unordered_map>
+#include <algorithm>
+#include <cmath>
 
 #include "sound_p.h"
 
 using namespace libscratchcpp;
 
+static std::unordered_map<Sound::Effect, std::pair<double, double>> EFFECT_RANGE = {
+    { Sound::Effect::Pitch, { -360, 360 } }, // -3 to 3 octaves
+    { Sound::Effect::Pan, { -100, 100 } }    // // 100% left to 100% right
+};
+
 /*! Constructs Sound. */
 Sound::Sound(const std::string &name, const std::string &id, const std::string &format) :
     Asset(name, id, format),
@@ -44,33 +53,80 @@ void Sound::setVolume(double volume)
     impl->player->setVolume(volume / 100);
 }
 
+/*! Sets the value of the given sound effect. */
+void Sound::setEffect(Effect effect, double value)
+{
+    auto it = EFFECT_RANGE.find(effect);
+
+    if (it == EFFECT_RANGE.cend())
+        return;
+
+    value = std::clamp(value, it->second.first, it->second.second);
+
+    switch (effect) {
+        case Effect::Pitch: {
+            // Convert from linear
+            const double root = std::pow(2, 1 / 12.0);
+            impl->player->setPitch(std::pow(root, value / 10));
+            break;
+        }
+
+        case Effect::Pan:
+            impl->player->setPan(value / 100);
+            break;
+    }
+}
+
 /*! Starts the playback of the sound. */
 void Sound::start()
 {
+    // Stop sounds in clones (#538)
+    stopCloneSounds();
     impl->player->start();
 }
 
 /*! Stops the playback of the sound. */
 void Sound::stop()
 {
+    // Stop sounds in clones (#538)
+    stopCloneSounds();
     impl->player->stop();
 }
 
 /*! Returns true if the sound is being played. */
-bool Sound::isPlaying()
+bool Sound::isPlaying() const
 {
     return impl->player->isPlaying();
 }
 
+/*! Returns the sprite or stage this variable belongs to. */
+Target *Sound::target() const
+{
+    return impl->target;
+}
+
+/*! Sets the sprite or stage this variable belongs to. */
+void Sound::setTarget(Target *target)
+{
+    impl->target = target;
+}
+
 /*! Returns an independent copy of the sound which is valid for as long as the original sound exists. */
 std::shared_ptr<Sound> Sound::clone() const
 {
+    const Sound *root = impl->cloneRoot ? impl->cloneRoot : this;
     auto sound = std::make_shared<Sound>(name(), id(), dataFormat());
     sound->setRate(rate());
     sound->setSampleCount(sampleCount());
-    sound->impl->player->loadCopy(impl->player.get());
+    sound->impl->cloneRoot = root;
     sound->impl->player->setVolume(impl->player->volume());
-    sound->setData(dataSize(), const_cast<void *>(data()));
+    sound->impl->player->setPitch(impl->player->pitch());
+    sound->impl->player->setPan(impl->player->pan());
+
+    if (root->impl->player->isLoaded()) {
+        sound->impl->player->loadCopy(root->impl->player.get());
+        sound->setData(dataSize(), const_cast<void *>(data()));
+    }
 
     return sound;
 }
@@ -83,3 +139,31 @@ void Sound::processData(unsigned int size, void *data)
     if (!impl->player->load(size, data, impl->rate))
         std::cerr << "Failed to load sound " << name() << std::endl;
 }
+
+void Sound::stopCloneSounds()
+{
+    if (impl->target && !impl->target->isStage()) {
+        Sprite *sprite = static_cast<Sprite *>(impl->target);
+
+        if (sprite->isClone())
+            sprite = sprite->cloneSprite();
+
+        // Stop the sound in the sprite (clone root)
+        const Sound *root = impl->cloneRoot ? impl->cloneRoot : this;
+        assert(root == sprite->soundAt(sprite->findSound(name())).get());
+
+        if (root != this)
+            root->impl->player->stop();
+
+        // Stop the sound in clones
+        const auto &clones = sprite->clones();
+
+        for (auto clone : clones) {
+            auto sound = clone->soundAt(clone->findSound(name()));
+            assert(sound);
+
+            if (sound && sound.get() != this)
+                sound->impl->player->stop();
+        }
+    }
+}
diff --git a/src/scratch/sound_p.h b/src/scratch/sound_p.h
index 082b05fd..3df2ca3f 100644
--- a/src/scratch/sound_p.h
+++ b/src/scratch/sound_p.h
@@ -10,6 +10,9 @@
 namespace libscratchcpp
 {
 
+class Target;
+class Sound;
+
 struct SoundPrivate
 {
         SoundPrivate();
@@ -19,6 +22,8 @@ struct SoundPrivate
         int sampleCount = 0;
         static IAudioOutput *audioOutput;
         std::shared_ptr<IAudioPlayer> player = nullptr;
+        Target *target = nullptr;
+        const Sound *cloneRoot = nullptr;
 };
 
 } // namespace libscratchcpp
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 8e9845fa..d711ca7c 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -226,6 +226,11 @@ bool Sprite::dragging() const
 void Sprite::startDragging()
 {
     impl->dragging = true;
+
+    IEngine *eng = engine();
+
+    if (eng)
+        eng->moveSpriteToFront(this);
 }
 
 /*! Stops dragging. */
@@ -258,13 +263,21 @@ double Sprite::size() const
 /*! Sets the size. */
 void Sprite::setSize(double newSize)
 {
+    IEngine *engine = this->engine();
+
+    if (engine) {
+        const int oldWidth = currentCostumeWidth();
+        const int oldHeight = currentCostumeHeight();
+        const double minScale = std::min(1.0, std::max(5.0 / oldWidth, 5.0 / oldHeight));
+        const double maxScale = std::min((1.5 * engine->stageWidth()) / oldWidth, (1.5 * engine->stageHeight()) / oldHeight);
+        newSize = std::clamp(newSize, minScale * 100, maxScale * 100);
+    }
+
     impl->size = newSize;
 
     if (impl->visible) {
-        IEngine *eng = engine();
-
-        if (eng)
-            eng->requestRedraw();
+        if (engine)
+            engine->requestRedraw();
     }
 
     if (impl->iface)
@@ -288,6 +301,24 @@ void Sprite::setCostumeIndex(int newCostumeIndex)
         impl->iface->onCostumeChanged(costume.get());
 }
 
+/*! Overrides Target#currentCostumeWidth(). */
+int Sprite::currentCostumeWidth() const
+{
+    if (!impl->iface)
+        return 0;
+
+    return impl->iface->costumeWidth();
+}
+
+/*! Overrides Target#currentCostumeHeight(). */
+int Sprite::currentCostumeHeight() const
+{
+    if (!impl->iface)
+        return 0;
+
+    return impl->iface->costumeHeight();
+}
+
 /*! Returns the direction. */
 double Sprite::direction() const
 {
diff --git a/src/scratch/stage.cpp b/src/scratch/stage.cpp
index a632570e..d798451e 100644
--- a/src/scratch/stage.cpp
+++ b/src/scratch/stage.cpp
@@ -46,6 +46,24 @@ void Stage::setCostumeIndex(int newCostumeIndex)
         impl->iface->onCostumeChanged(costume.get());
 }
 
+/*! Overrides Target#currentCostumeWidth(). */
+int Stage::currentCostumeWidth() const
+{
+    if (!impl->iface)
+        return 0;
+
+    return impl->iface->costumeWidth();
+}
+
+/*! Overrides Target#currentCostumeHeight(). */
+int Stage::currentCostumeHeight() const
+{
+    if (!impl->iface)
+        return 0;
+
+    return impl->iface->costumeHeight();
+}
+
 /*! Returns the tempo. */
 int Stage::tempo() const
 {
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 14a6f337..1e9f4b46 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -278,6 +278,18 @@ std::shared_ptr<Costume> Target::currentCostume() const
     return costumeAt(impl->costumeIndex);
 }
 
+/*! Returns the width of the current costume. */
+int Target::currentCostumeWidth() const
+{
+    return 0;
+}
+
+/*! Returns the height of the current costume. */
+int Target::currentCostumeHeight() const
+{
+    return 0;
+}
+
 /*! Returns the list of costumes. */
 const std::vector<std::shared_ptr<Costume>> &Target::costumes() const
 {
@@ -344,9 +356,14 @@ int Target::addSound(std::shared_ptr<Sound> sound)
 
     assert(sound);
 
-    if (sound)
+    if (sound) {
+        sound->setTarget(this);
         sound->setVolume(impl->volume);
 
+        for (const auto &[effect, value] : impl->soundEffects)
+            sound->setEffect(effect, value);
+    }
+
     impl->sounds.push_back(sound);
     return impl->sounds.size() - 1;
 }
@@ -405,6 +422,39 @@ void Target::setVolume(double newVolume)
     }
 }
 
+/*! Returns the value of the given sound effect. */
+double Target::soundEffectValue(Sound::Effect effect) const
+{
+    auto it = impl->soundEffects.find(effect);
+
+    if (it != impl->soundEffects.cend())
+        return it->second;
+
+    return 0;
+}
+
+/*! Sets the value of the given sound effect. */
+void Target::setSoundEffectValue(Sound::Effect effect, double value)
+{
+    impl->soundEffects[effect] = value;
+
+    for (auto sound : impl->sounds) {
+        if (sound)
+            sound->setEffect(effect, value);
+    }
+}
+
+/*! Sets the value of all sound effects to 0 (clears them). */
+void Target::clearSoundEffects()
+{
+    std::unordered_map<Sound::Effect, double> effects = impl->soundEffects; // must copy!
+
+    for (const auto &[effect, value] : effects)
+        setSoundEffectValue(effect, 0);
+
+    impl->soundEffects.clear();
+}
+
 /*! Returns the bounding rectangle of the sprite. */
 Rect Target::boundingRect() const
 {
diff --git a/src/scratch/target_p.h b/src/scratch/target_p.h
index 73db4087..71b7c48b 100644
--- a/src/scratch/target_p.h
+++ b/src/scratch/target_p.h
@@ -36,6 +36,7 @@ struct TargetPrivate
         std::vector<std::shared_ptr<Sound>> sounds;
         int layerOrder = 0;
         double volume = 100;
+        std::unordered_map<Sound::Effect, double> soundEffects;
         std::unordered_map<IGraphicsEffect *, double> graphicsEffects;
         Target::BubbleType bubbleType = Target::BubbleType::Say;
         std::string bubbleText;
diff --git a/src/scratch/value.cpp b/src/scratch/value.cpp
new file mode 100644
index 00000000..f3d8ad46
--- /dev/null
+++ b/src/scratch/value.cpp
@@ -0,0 +1,9 @@
+#include <scratchcpp/value.h>
+#include <utf8.h>
+
+using namespace libscratchcpp;
+
+std::u16string Value::toUtf16() const
+{
+    return utf8::utf8to16(toString());
+}
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
index 3cd80665..5fd8c636 100644
--- a/test/assets/sound_test.cpp
+++ b/test/assets/sound_test.cpp
@@ -1,7 +1,9 @@
 #include <scratchcpp/sound.h>
+#include <scratchcpp/sprite.h>
 #include <scratch/sound_p.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
+#include <enginemock.h>
 
 #include "../common.h"
 
@@ -77,6 +79,55 @@ TEST_F(SoundTest, SetVolume)
     sound.setVolume(56.04);
 }
 
+TEST_F(SoundTest, SetEffect)
+{
+    Sound sound("sound1", "a", "wav");
+
+    // Pitch
+    EXPECT_CALL(*m_player, setPitch(0.125));
+    sound.setEffect(Sound::Effect::Pitch, -400);
+
+    EXPECT_CALL(*m_player, setPitch(0.125));
+    sound.setEffect(Sound::Effect::Pitch, -360);
+
+    EXPECT_CALL(*m_player, setPitch(0.5));
+    sound.setEffect(Sound::Effect::Pitch, -120);
+
+    EXPECT_CALL(*m_player, setPitch(1));
+    sound.setEffect(Sound::Effect::Pitch, 0);
+
+    EXPECT_CALL(*m_player, setPitch(2));
+    sound.setEffect(Sound::Effect::Pitch, 120);
+
+    EXPECT_CALL(*m_player, setPitch(8));
+    sound.setEffect(Sound::Effect::Pitch, 360);
+
+    EXPECT_CALL(*m_player, setPitch(8));
+    sound.setEffect(Sound::Effect::Pitch, 400);
+
+    // Pan
+    EXPECT_CALL(*m_player, setPan(-1));
+    sound.setEffect(Sound::Effect::Pan, -150);
+
+    EXPECT_CALL(*m_player, setPan(-1));
+    sound.setEffect(Sound::Effect::Pan, -100);
+
+    EXPECT_CALL(*m_player, setPan(-0.5));
+    sound.setEffect(Sound::Effect::Pan, -50);
+
+    EXPECT_CALL(*m_player, setPan(0));
+    sound.setEffect(Sound::Effect::Pan, 0);
+
+    EXPECT_CALL(*m_player, setPan(0.5));
+    sound.setEffect(Sound::Effect::Pan, 50);
+
+    EXPECT_CALL(*m_player, setPan(1));
+    sound.setEffect(Sound::Effect::Pan, 100);
+
+    EXPECT_CALL(*m_player, setPan(1));
+    sound.setEffect(Sound::Effect::Pan, 150);
+}
+
 TEST_F(SoundTest, Start)
 {
     Sound sound("sound1", "a", "wav");
@@ -106,30 +157,111 @@ TEST_F(SoundTest, IsPlaying)
     SoundPrivate::audioOutput = nullptr;
 }
 
-TEST_F(SoundTest, Clone)
+TEST_F(SoundTest, Target)
 {
     Sound sound("sound1", "a", "wav");
-    sound.setRate(44100);
-    sound.setSampleCount(10000);
+    ASSERT_EQ(sound.target(), nullptr);
+
+    Target target;
+    sound.setTarget(&target);
+    ASSERT_EQ(sound.target(), &target);
+}
+
+TEST_F(SoundTest, Clone)
+{
+    auto sound = std::make_shared<Sound>("sound1", "a", "wav");
+    sound->setRate(44100);
+    sound->setSampleCount(10000);
 
     const char *data = "abc";
     void *dataPtr = const_cast<void *>(static_cast<const void *>(data));
 
     EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(false));
     EXPECT_CALL(*m_player, load(3, dataPtr, 44100)).WillOnce(Return(true));
-    sound.setData(3, dataPtr);
+    sound->setData(3, dataPtr);
 
     auto clonePlayer = std::make_shared<AudioPlayerMock>();
     EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(clonePlayer));
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(true));
     EXPECT_CALL(*clonePlayer, loadCopy(m_player.get())).WillOnce(Return(true));
     EXPECT_CALL(*m_player, volume()).WillOnce(Return(0.45));
     EXPECT_CALL(*clonePlayer, setVolume(0.45));
+    EXPECT_CALL(*m_player, pitch()).WillOnce(Return(1.25));
+    EXPECT_CALL(*clonePlayer, setPitch(1.25));
+    EXPECT_CALL(*m_player, pan()).WillOnce(Return(-0.75));
+    EXPECT_CALL(*clonePlayer, setPan(-0.75));
     EXPECT_CALL(*clonePlayer, isLoaded()).WillOnce(Return(true));
-    auto clone = sound.clone();
+    auto clone = sound->clone();
     ASSERT_TRUE(clone);
-    ASSERT_EQ(clone->name(), sound.name());
-    ASSERT_EQ(clone->id(), sound.id());
-    ASSERT_EQ(clone->dataFormat(), sound.dataFormat());
-    ASSERT_EQ(clone->rate(), sound.rate());
-    ASSERT_EQ(clone->sampleCount(), sound.sampleCount());
+    ASSERT_EQ(clone->name(), sound->name());
+    ASSERT_EQ(clone->id(), sound->id());
+    ASSERT_EQ(clone->dataFormat(), sound->dataFormat());
+    ASSERT_EQ(clone->rate(), sound->rate());
+    ASSERT_EQ(clone->sampleCount(), sound->sampleCount());
+
+    auto cloneClonePlayer = std::make_shared<AudioPlayerMock>();
+    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(cloneClonePlayer));
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(true));
+    EXPECT_CALL(*cloneClonePlayer, loadCopy(m_player.get())).WillOnce(Return(true));
+    EXPECT_CALL(*clonePlayer, volume()).WillOnce(Return(0.62));
+    EXPECT_CALL(*cloneClonePlayer, setVolume(0.62));
+    EXPECT_CALL(*clonePlayer, pitch()).WillOnce(Return(0.5));
+    EXPECT_CALL(*cloneClonePlayer, setPitch(0.5));
+    EXPECT_CALL(*clonePlayer, pan()).WillOnce(Return(0.25));
+    EXPECT_CALL(*cloneClonePlayer, setPan(0.25));
+    EXPECT_CALL(*cloneClonePlayer, isLoaded()).WillOnce(Return(true));
+    auto cloneClone = clone->clone();
+    ASSERT_TRUE(cloneClone);
+
+    auto anotherClonePlayer = std::make_shared<AudioPlayerMock>();
+    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(anotherClonePlayer));
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(false));
+    EXPECT_CALL(*anotherClonePlayer, loadCopy).Times(0);
+    EXPECT_CALL(*clonePlayer, volume()).WillOnce(Return(0.62));
+    EXPECT_CALL(*anotherClonePlayer, setVolume(0.62));
+    EXPECT_CALL(*clonePlayer, pitch()).WillOnce(Return(2));
+    EXPECT_CALL(*anotherClonePlayer, setPitch(2));
+    EXPECT_CALL(*clonePlayer, pan()).WillOnce(Return(1));
+    EXPECT_CALL(*anotherClonePlayer, setPan(1));
+    EXPECT_CALL(*anotherClonePlayer, isLoaded()).Times(0);
+    auto anotherClone = clone->clone();
+    ASSERT_TRUE(anotherClone);
+
+    // Stopping/starting the sound should stop its clones
+    auto anotherPlayer = std::make_shared<AudioPlayerMock>();
+    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(anotherPlayer));
+    auto another = std::make_shared<Sound>("another", "c", "mp3");
+    Sprite sprite;
+    EngineMock engine;
+    sprite.setEngine(&engine);
+
+    EXPECT_CALL(engine, cloneLimit()).WillOnce(Return(-1));
+    EXPECT_CALL(engine, initClone);
+    EXPECT_CALL(engine, requestRedraw);
+    EXPECT_CALL(engine, moveSpriteBehindOther);
+    auto spriteClone = sprite.clone();
+
+    EXPECT_CALL(*anotherPlayer, setVolume).Times(2);
+    EXPECT_CALL(*m_player, setVolume);
+    EXPECT_CALL(*clonePlayer, setVolume);
+    sprite.addSound(another);
+    sprite.addSound(sound);
+    spriteClone->addSound(another);
+    spriteClone->addSound(clone);
+
+    EXPECT_CALL(*m_player, stop());
+    EXPECT_CALL(*clonePlayer, stop());
+    sound->stop();
+
+    EXPECT_CALL(*m_player, stop());
+    EXPECT_CALL(*clonePlayer, stop());
+    clone->stop();
+
+    EXPECT_CALL(*m_player, start());
+    EXPECT_CALL(*clonePlayer, stop());
+    sound->start();
+
+    EXPECT_CALL(*m_player, stop());
+    EXPECT_CALL(*clonePlayer, start());
+    clone->start();
 }
diff --git a/test/audio/CMakeLists.txt b/test/audio/CMakeLists.txt
index c4aba7b4..40897a6e 100644
--- a/test/audio/CMakeLists.txt
+++ b/test/audio/CMakeLists.txt
@@ -1,3 +1,21 @@
+# audioengine_test
+add_executable(
+  audioengine_test
+  audioengine_test.cpp
+)
+
+target_link_libraries(
+  audioengine_test
+  GTest::gtest_main
+  scratchcpp
+)
+
+gtest_discover_tests(audioengine_test)
+
+if (LIBSCRATCHCPP_AUDIO_SUPPORT)
+    target_compile_definitions(audioengine_test PRIVATE LIBSCRATCHCPP_AUDIO_SUPPORT)
+endif()
+
 # audiooutput_test
 add_executable(
   audiooutput_test
diff --git a/test/audio/audioengine_test.cpp b/test/audio/audioengine_test.cpp
new file mode 100644
index 00000000..e0476858
--- /dev/null
+++ b/test/audio/audioengine_test.cpp
@@ -0,0 +1,31 @@
+#ifdef LIBSCRATCHCPP_AUDIO_SUPPORT
+#include <audio/internal/audioengine.h>
+#else
+#include <audio/internal/audioenginestub.h>
+#endif
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(AudioEngineTest, Instance)
+{
+    IAudioEngine *instance = IAudioEngine::instance();
+    ASSERT_TRUE(instance);
+
+#ifdef LIBSCRATCHCPP_AUDIO_SUPPORT
+    ASSERT_TRUE(dynamic_cast<AudioEngine *>(instance));
+#else
+    ASSERT_TRUE(dynamic_cast<AudioEngineStub *>(instance));
+#endif
+}
+
+TEST(AudioEngineTest, Volume)
+{
+    IAudioEngine *engine = IAudioEngine::instance();
+    ASSERT_TRUE(engine);
+    ASSERT_EQ(engine->volume(), 1.0f);
+
+    engine->setVolume(0.86f);
+    ASSERT_EQ(engine->volume(), 0.86f);
+}
diff --git a/test/audio/audioplayer_test.cpp b/test/audio/audioplayer_test.cpp
index cd19a920..7505a75d 100644
--- a/test/audio/audioplayer_test.cpp
+++ b/test/audio/audioplayer_test.cpp
@@ -12,3 +12,12 @@ TEST(AudioPlayerTest, Volume)
     player.setVolume(0.86f);
     ASSERT_EQ(player.volume(), 0.86f);
 }
+
+TEST(AudioPlayerTest, Pitch)
+{
+    AudioPlayer player;
+    ASSERT_EQ(player.pitch(), 1);
+
+    player.setPitch(1.5f);
+    ASSERT_EQ(player.pitch(), 1.5f);
+}
diff --git a/test/blocks/control_blocks_test.cpp b/test/blocks/control_blocks_test.cpp
index 16145999..a49acbea 100644
--- a/test/blocks/control_blocks_test.cpp
+++ b/test/blocks/control_blocks_test.cpp
@@ -41,6 +41,7 @@ class ControlBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, "CLONE_OPTION", ControlBlocks::CLONE_OPTION);
                 auto menu = createControlBlock(id + "_menu", "control_create_clone_of_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, "CLONE_OPTION", static_cast<ControlBlocks::Fields>(-1), spriteName, static_cast<ControlBlocks::FieldValues>(-1));
             }
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 8b2be2e8..5a6db769 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -4,12 +4,14 @@
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/broadcast.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/costume.h>
 #include <enginemock.h>
 #include <audioinputmock.h>
 #include <audioloudnessmock.h>
 #include <timermock.h>
+#include <targetmock.h>
 
 #include "../common.h"
 #include "blocks/eventblocks.h"
@@ -35,6 +37,15 @@ class EventBlocksTest : public testing::Test
         // For any event block
         std::shared_ptr<Block> createEventBlock(const std::string &id, const std::string &opcode) const { return std::make_shared<Block>(id, opcode); }
 
+        std::shared_ptr<Block> createNullBlock(const std::string &id)
+        {
+            std::shared_ptr<Block> block = std::make_shared<Block>(id, "");
+            BlockComp func = [](Compiler *compiler) { compiler->addInstruction(vm::OP_NULL); };
+            block->setCompileFunction(func);
+
+            return block;
+        }
+
         void addBroadcastInput(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Inputs id, std::shared_ptr<Broadcast> broadcast) const
         {
             auto input = std::make_shared<Input>(name, Input::Type::Shadow);
@@ -45,6 +56,15 @@ class EventBlocksTest : public testing::Test
             block->addInput(input);
         }
 
+        std::shared_ptr<Input> addNullInput(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Inputs id) const
+        {
+            auto input = std::make_shared<Input>(name, Input::Type::Shadow);
+            input->setInputId(id);
+            block->addInput(input);
+
+            return input;
+        }
+
         void addValueInput(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Inputs id, const Value &value) const
         {
             auto input = std::make_shared<Input>(name, Input::Type::Shadow);
@@ -61,6 +81,27 @@ class EventBlocksTest : public testing::Test
             block->addInput(input);
         }
 
+        void addDropdownInput(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Inputs id, const std::string &selectedValue, std::shared_ptr<Block> valueBlock = nullptr) const
+        {
+            if (valueBlock)
+                addObscuredInput(block, name, id, valueBlock);
+            else {
+                auto input = addNullInput(block, name, id);
+                auto menu = std::make_shared<Block>(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
+                input->setValueBlock(menu);
+                addDropdownField(menu, name, static_cast<EventBlocks::Fields>(-1), selectedValue, static_cast<EventBlocks::FieldValues>(-1));
+            }
+        }
+
+        void addDropdownField(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Fields id, const std::string &value, EventBlocks::FieldValues valueId) const
+        {
+            auto field = std::make_shared<Field>(name, value);
+            field->setFieldId(id);
+            field->setSpecialValueId(valueId);
+            block->addField(field);
+        }
+
         void addValueField(std::shared_ptr<Block> block, const std::string &name, EventBlocks::Fields id, const std::string &value, int valueId = -1) const
         {
             auto field = std::make_shared<Field>(name, value);
@@ -95,6 +136,7 @@ TEST_F(EventBlocksTest, CategoryVisible)
 TEST_F(EventBlocksTest, RegisterBlocks)
 {
     // Blocks
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whentouchingobject", &EventBlocks::compileWhenTouchingObject));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenflagclicked", &EventBlocks::compileWhenFlagClicked));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenthisspriteclicked", &EventBlocks::compileWhenThisSpriteClicked));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenstageclicked", &EventBlocks::compileWhenStageClicked));
@@ -106,9 +148,11 @@ TEST_F(EventBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenkeypressed", &EventBlocks::compileWhenKeyPressed));
 
     // Hat predicates
+    EXPECT_CALL(m_engineMock, addHatPredicateCompileFunction(m_section.get(), "event_whentouchingobject", &EventBlocks::compileWhenTouchingObjectPredicate));
     EXPECT_CALL(m_engineMock, addHatPredicateCompileFunction(m_section.get(), "event_whengreaterthan", &EventBlocks::compileWhenGreaterThanPredicate));
 
     // Inputs
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VALUE", EventBlocks::VALUE));
 
@@ -125,6 +169,136 @@ TEST_F(EventBlocksTest, RegisterBlocks)
     m_section->registerBlocks(&m_engineMock);
 }
 
+TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
+{
+    Compiler compiler(&m_engineMock);
+
+    // when touching (Sprite1)
+    auto block1 = createEventBlock("a", "event_whentouchingobject");
+    addDropdownInput(block1, "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU, "Sprite1");
+
+    // when touching (null block)
+    auto block2 = createEventBlock("b", "event_whentouchingobject");
+    addDropdownInput(block2, "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU, "", createNullBlock("e"));
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::whenTouchingObjectPredicate)).WillOnce(Return(0));
+    compiler.setBlock(block1);
+    EventBlocks::compileWhenTouchingObjectPredicate(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::whenTouchingObjectPredicate)).WillOnce(Return(0));
+    compiler.setBlock(block2);
+    EventBlocks::compileWhenTouchingObjectPredicate(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_NULL, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues().size(), 1);
+    ASSERT_EQ(compiler.constValues()[0], "Sprite1");
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
+TEST_F(EventBlocksTest, WhenTouchingObjectPredicateImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &EventBlocks::whenTouchingObjectPredicate };
+    static Value constValues[] = { "Sprite2", "_mouse_", "_edge_", "", 1, -1, 2 };
+
+    TargetMock target;
+    target.setEngine(&m_engineMock);
+    Sprite sprite;
+    VirtualMachine vm(&target, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    // touching "Sprite2"
+    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, targetAt(3)).WillOnce(Return(&sprite));
+    EXPECT_CALL(target, touchingClones).WillOnce(Return(false));
+    vm.setBytecode(bytecode1);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, targetAt(3)).WillOnce(Return(&sprite));
+    EXPECT_CALL(target, touchingClones).WillOnce(Return(true));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+
+    // touching "_mouse_"
+    EXPECT_CALL(m_engineMock, mouseX()).WillOnce(Return(24.5));
+    EXPECT_CALL(m_engineMock, mouseY()).WillOnce(Return(-16.04));
+    EXPECT_CALL(target, touchingPoint(24.5, -16.04)).WillOnce(Return(true));
+    vm.setBytecode(bytecode2);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+
+    // touching "_edge_"
+    EXPECT_CALL(m_engineMock, stageWidth()).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, stageHeight()).WillOnce(Return(0));
+    EXPECT_CALL(target, boundingRect()).WillOnce(Return(Rect(-5, 5, 5, -5)));
+    vm.setBytecode(bytecode3);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(m_engineMock, stageWidth()).WillOnce(Return(10));
+    EXPECT_CALL(m_engineMock, stageHeight()).WillOnce(Return(10));
+    EXPECT_CALL(target, boundingRect()).WillOnce(Return(Rect(-5, 5, 5, -5)));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+
+    // touching ""
+    EXPECT_CALL(m_engineMock, findTarget("")).WillOnce(Return(-1));
+    EXPECT_CALL(m_engineMock, targetAt(-1)).WillOnce(Return(nullptr));
+    vm.setBytecode(bytecode4);
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+}
+
+TEST_F(EventBlocksTest, WhenTouchingObject)
+{
+    Compiler compiler(&m_engineMock);
+
+    // when touching (Sprite1)
+    auto block = createEventBlock("a", "event_whentouchingobject");
+    addDropdownInput(block, "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU, "Sprite1");
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, addWhenTouchingObjectScript(block));
+    compiler.setBlock(block);
+    EventBlocks::compileWhenTouchingObject(&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, WhenFlagClicked)
 {
     Compiler compiler(&m_engineMock);
@@ -199,8 +373,8 @@ TEST_F(EventBlocksTest, Broadcast)
     notBlock->setCompileFunction(&OperatorBlocks::compileNot);
     addObscuredInput(block2, "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT, notBlock);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndex)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 0, 3 })));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndex)).Times(2).WillRepeatedly(Return(0));
     EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcast)).WillOnce(Return(1));
 
     compiler.init();
@@ -210,9 +384,8 @@ TEST_F(EventBlocksTest, Broadcast)
     EventBlocks::compileBroadcast(&compiler);
     compiler.end();
 
-    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 1, vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues().size(), 1);
-    ASSERT_EQ(compiler.constValues()[0].toDouble(), 0);
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 0, 3 }));
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
@@ -228,8 +401,9 @@ TEST_F(EventBlocksTest, BroadcastImpl)
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, broadcast(1)).Times(1);
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 1, 4 })));
+    EXPECT_CALL(m_engineMock, broadcast(1));
+    EXPECT_CALL(m_engineMock, broadcast(4));
 
     vm.setBytecode(bytecode1);
     vm.run();
@@ -258,9 +432,9 @@ TEST_F(EventBlocksTest, BroadcastAndWait)
     notBlock->setCompileFunction(&OperatorBlocks::compileNot);
     addObscuredInput(block2, "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT, notBlock);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndexAndWait)).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::checkBroadcastByIndex)).WillOnce(Return(1));
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 0, 3 })));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastByIndexAndWait)).Times(2).WillRepeatedly(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::checkBroadcastByIndex)).Times(2).WillRepeatedly(Return(1));
     EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastAndWait)).WillOnce(Return(2));
     EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::checkBroadcast)).WillOnce(Return(3));
 
@@ -274,8 +448,9 @@ TEST_F(EventBlocksTest, BroadcastAndWait)
     ASSERT_EQ(
         compiler.bytecode(),
         std::vector<unsigned int>(
-            { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 2, vm::OP_NULL, vm::OP_NOT, vm::OP_EXEC, 3, vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 0, 0 }));
+            { vm::OP_START, vm::OP_CONST, 0,           vm::OP_EXEC, 0,           vm::OP_CONST, 1,           vm::OP_EXEC, 0,          vm::OP_CONST, 2, vm::OP_EXEC, 1, vm::OP_CONST, 3, vm::OP_EXEC, 1,
+              vm::OP_NULL,  vm::OP_NOT,   vm::OP_EXEC, 2,           vm::OP_NULL, vm::OP_NOT,   vm::OP_EXEC, 3,           vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 0, 3, 0, 3 }));
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
@@ -293,15 +468,16 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, broadcast(1)).Times(1);
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 1, 4 })));
+    EXPECT_CALL(m_engineMock, broadcast(1));
+    EXPECT_CALL(m_engineMock, broadcast(4));
 
     vm.setBytecode(bytecode1);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(2));
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 2, 3 })));
     EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(true));
 
     vm.setBytecode(bytecode2);
@@ -310,8 +486,18 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(vm.atEnd(), false);
 
-    EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(2));
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 2, 3 })));
+    EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(true));
+
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.atEnd(), false);
+
+    EXPECT_CALL(m_engineMock, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 2, 3 })));
     EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastRunning(3)).WillOnce(Return(false));
 
     vm.run();
 
diff --git a/test/blocks/looks_blocks_test.cpp b/test/blocks/looks_blocks_test.cpp
index 2bf1e44a..950187b7 100644
--- a/test/blocks/looks_blocks_test.cpp
+++ b/test/blocks/looks_blocks_test.cpp
@@ -75,6 +75,7 @@ class LooksBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = createLooksBlock(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<LooksBlocks::Fields>(-1), selectedValue, static_cast<LooksBlocks::FieldValues>(-1));
             }
diff --git a/test/blocks/motion_blocks_test.cpp b/test/blocks/motion_blocks_test.cpp
index 399b2030..4a2853ca 100644
--- a/test/blocks/motion_blocks_test.cpp
+++ b/test/blocks/motion_blocks_test.cpp
@@ -74,6 +74,7 @@ class MotionBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = createMotionBlock(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<MotionBlocks::Fields>(-1), selectedValue, static_cast<MotionBlocks::FieldValues>(-1));
             }
diff --git a/test/blocks/sensing_blocks_test.cpp b/test/blocks/sensing_blocks_test.cpp
index 3ad92fae..ecc61337 100644
--- a/test/blocks/sensing_blocks_test.cpp
+++ b/test/blocks/sensing_blocks_test.cpp
@@ -86,6 +86,7 @@ class SensingBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = std::make_shared<Block>(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<SensingBlocks::Fields>(-1), selectedValue, static_cast<SensingBlocks::FieldValues>(-1));
             }
@@ -1356,8 +1357,8 @@ TEST_F(SensingBlocksTest, Of)
 
     compiler.init();
 
-    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).Times(9).WillRepeatedly(Return(6));
-    EXPECT_CALL(m_engineMock, findTarget("_stage_")).Times(5).WillRepeatedly(Return(0));
+    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillRepeatedly(Return(6));
+    EXPECT_CALL(m_engineMock, findTarget("_stage_")).WillRepeatedly(Return(0));
 
     EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::xPositionOfSpriteByIndex)).WillOnce(Return(0));
     compiler.setBlock(block1);
@@ -1444,10 +1445,12 @@ TEST_F(SensingBlocksTest, Of)
     auto v2 = std::make_shared<Variable>("var2", "some variable");
     stage.addVariable(v1);
     stage.addVariable(v2);
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
     compiler.setBlock(block21);
     SensingBlocks::compileOf(&compiler);
 
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
     compiler.setBlock(block22);
     SensingBlocks::compileOf(&compiler);
@@ -1455,10 +1458,12 @@ TEST_F(SensingBlocksTest, Of)
     Sprite sprite;
     auto v3 = std::make_shared<Variable>("var3", "some variable");
     sprite.addVariable(v3);
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
     compiler.setBlock(block23);
     SensingBlocks::compileOf(&compiler);
 
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
     compiler.setBlock(block24);
     SensingBlocks::compileOf(&compiler);
@@ -1547,21 +1552,37 @@ TEST_F(SensingBlocksTest, Of)
               vm::OP_NULL,
               vm::OP_EXEC,
               17,
-              vm::OP_READ_VAR,
-              0,
+              vm::OP_CONST,
+              10,
+              vm::OP_CONST,
+              11,
+              vm::OP_EXEC,
+              19,
               vm::OP_NULL,
-              vm::OP_READ_VAR,
-              1,
+              vm::OP_CONST,
+              12,
+              vm::OP_EXEC,
+              19,
+              vm::OP_CONST,
+              13,
+              vm::OP_CONST,
+              14,
+              vm::OP_EXEC,
+              19,
               vm::OP_NULL,
               vm::OP_CONST,
-              10,
+              15,
+              vm::OP_EXEC,
+              19,
+              vm::OP_CONST,
+              16,
               vm::OP_NULL,
               vm::OP_EXEC,
               18,
               vm::OP_NULL,
               vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, "some variable" }));
-    ASSERT_EQ(compiler.variables(), std::vector<Variable *>({ v2.get(), v3.get() }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 1, 0, 0, 0, 6, 6, "some variable" }));
+    ASSERT_TRUE(compiler.variables().empty());
 }
 
 TEST_F(SensingBlocksTest, XPositionOfSprite)
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
index c5b2b366..96992550 100644
--- a/test/blocks/sound_blocks_test.cpp
+++ b/test/blocks/sound_blocks_test.cpp
@@ -2,12 +2,12 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
-#include <scratchcpp/target.h>
 #include <scratchcpp/sound.h>
 #include <scratch/sound_p.h>
 #include <enginemock.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
+#include <targetmock.h>
 
 #include "../common.h"
 #include "blocks/soundblocks.h"
@@ -67,6 +67,7 @@ class SoundBlocksTest : public testing::Test
             else {
                 auto input = addNullInput(block, name, id);
                 auto menu = std::make_shared<Block>(block->id() + "_menu", block->opcode() + "_menu");
+                menu->setShadow(true);
                 input->setValueBlock(menu);
                 addDropdownField(menu, name, static_cast<SoundBlocks::Fields>(-1), selectedValue, static_cast<SoundBlocks::FieldValues>(-1));
             }
@@ -101,7 +102,10 @@ TEST_F(SoundBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_play", &SoundBlocks::compilePlay));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_playuntildone", &SoundBlocks::compilePlayUntilDone));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_stopallsounds", &SoundBlocks::compileStopAllSounds));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_seteffectto", &SoundBlocks::compileSetEffectTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_changeeffectby", &SoundBlocks::compileChangeEffectBy));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_changevolumeby", &SoundBlocks::compileChangeVolumeBy));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_cleareffects", &SoundBlocks::compileClearEffects));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_setvolumeto", &SoundBlocks::compileSetVolumeTo));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sound_volume", &SoundBlocks::compileVolume));
 
@@ -110,8 +114,16 @@ TEST_F(SoundBlocksTest, RegisterBlocks)
 
     // Inputs
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SOUND_MENU", SoundBlocks::SOUND_MENU));
+    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VALUE", SoundBlocks::VALUE));
     EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VOLUME", SoundBlocks::VOLUME));
 
+    // Fields
+    EXPECT_CALL(m_engineMock, addField(m_section.get(), "EFFECT", SoundBlocks::EFFECT));
+
+    // Field values
+    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "PITCH", SoundBlocks::PITCH));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "PAN", SoundBlocks::PAN));
+
     m_section->registerBlocks(&m_engineMock);
 }
 
@@ -212,7 +224,8 @@ TEST_F(SoundBlocksTest, PlayImpl)
     EXPECT_CALL(*player1, setVolume);
     EXPECT_CALL(*player2, setVolume);
     EXPECT_CALL(*player3, setVolume);
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, isStage()).WillRepeatedly(Return(true));
     target.addSound(std::make_shared<Sound>("some sound", "", ""));
     target.addSound(std::make_shared<Sound>("test", "", ""));
     target.addSound(std::make_shared<Sound>("another sound", "", ""));
@@ -412,7 +425,8 @@ TEST_F(SoundBlocksTest, PlayUntilDoneImpl)
     EXPECT_CALL(*player1, setVolume);
     EXPECT_CALL(*player2, setVolume);
     EXPECT_CALL(*player3, setVolume);
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, isStage()).WillRepeatedly(Return(true));
     target.addSound(std::make_shared<Sound>("some sound", "", ""));
     target.addSound(std::make_shared<Sound>("test", "", ""));
     target.addSound(std::make_shared<Sound>("another sound", "", ""));
@@ -586,6 +600,156 @@ TEST_F(SoundBlocksTest, StopAllSoundsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
 }
 
+TEST_F(SoundBlocksTest, SetEffectTo)
+{
+    Compiler compiler(&m_engineMock);
+
+    // set [pitch] effect to (5.3)
+    auto block1 = std::make_shared<Block>("a", "sound_seteffectto");
+    addDropdownField(block1, "EFFECT", SoundBlocks::EFFECT, "PITCH", SoundBlocks::PITCH);
+    addValueInput(block1, "VALUE", SoundBlocks::VALUE, 5.3);
+
+    // set [pan] effect to (-79.52)
+    auto block2 = std::make_shared<Block>("b", "sound_seteffectto");
+    addDropdownField(block2, "EFFECT", SoundBlocks::EFFECT, "PAN", SoundBlocks::PAN);
+    addValueInput(block2, "VALUE", SoundBlocks::VALUE, -79.52);
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::setPitchEffectTo)).WillOnce(Return(0));
+    compiler.setBlock(block1);
+    SoundBlocks::compileSetEffectTo(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::setPanEffectTo)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    SoundBlocks::compileSetEffectTo(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 5.3, -79.52 }));
+}
+
+TEST_F(SoundBlocksTest, SetEffectToImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT };
+    static BlockFunc functions[] = { &SoundBlocks::setPitchEffectTo, &SoundBlocks::setPanEffectTo };
+    static Value constValues[] = { -20.7, 12.53 };
+
+    TargetMock target;
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode1);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    EXPECT_CALL(target, setSoundEffectValue(Sound::Effect::Pitch, -20.7));
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+
+    EXPECT_CALL(target, setSoundEffectValue(Sound::Effect::Pan, 12.53));
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+}
+
+TEST_F(SoundBlocksTest, ChangeEffectBy)
+{
+    Compiler compiler(&m_engineMock);
+
+    // change [pitch] effect by (5.3)
+    auto block1 = std::make_shared<Block>("a", "sound_changeeffectby");
+    addDropdownField(block1, "EFFECT", SoundBlocks::EFFECT, "PITCH", SoundBlocks::PITCH);
+    addValueInput(block1, "VALUE", SoundBlocks::VALUE, 5.3);
+
+    // change [pan] effect by (-79.52)
+    auto block2 = std::make_shared<Block>("b", "sound_changeeffectby");
+    addDropdownField(block2, "EFFECT", SoundBlocks::EFFECT, "PAN", SoundBlocks::PAN);
+    addValueInput(block2, "VALUE", SoundBlocks::VALUE, -79.52);
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::changePitchEffectBy)).WillOnce(Return(0));
+    compiler.setBlock(block1);
+    SoundBlocks::compileChangeEffectBy(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::changePanEffectBy)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    SoundBlocks::compileChangeEffectBy(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 5.3, -79.52 }));
+}
+
+TEST_F(SoundBlocksTest, ChangeEffectByImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT };
+    static BlockFunc functions[] = { &SoundBlocks::changePitchEffectBy, &SoundBlocks::changePanEffectBy };
+    static Value constValues[] = { -20.7, 12.53 };
+
+    TargetMock target;
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode1);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    EXPECT_CALL(target, soundEffectValue(Sound::Effect::Pitch)).WillOnce(Return(56));
+    EXPECT_CALL(target, setSoundEffectValue(Sound::Effect::Pitch, 35.3));
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+
+    EXPECT_CALL(target, soundEffectValue(Sound::Effect::Pan)).WillOnce(Return(-2.5));
+    EXPECT_CALL(target, setSoundEffectValue(Sound::Effect::Pan, 10.03));
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+}
+
+TEST_F(SoundBlocksTest, ClearEffects)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "sound_cleareffects");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SoundBlocks::clearEffects)).WillOnce(Return(0));
+
+    compiler.init();
+    compiler.setBlock(block);
+    SoundBlocks::compileClearEffects(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+}
+
+TEST_F(SoundBlocksTest, ClearEffectsImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SoundBlocks::clearEffects };
+
+    TargetMock target;
+    VirtualMachine vm(&target, nullptr, nullptr);
+
+    vm.setBytecode(bytecode);
+    vm.setFunctions(functions);
+
+    EXPECT_CALL(target, clearSoundEffects());
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+}
+
 TEST_F(SoundBlocksTest, ChangeVolumeBy)
 {
     Compiler compiler(&m_engineMock);
diff --git a/test/compiler/CMakeLists.txt b/test/compiler/CMakeLists.txt
index 867f0265..9dd42696 100644
--- a/test/compiler/CMakeLists.txt
+++ b/test/compiler/CMakeLists.txt
@@ -9,6 +9,7 @@ target_link_libraries(
   compiler_test
   GTest::gtest_main
   scratchcpp
+  nlohmann_json::nlohmann_json
 )
 
 gtest_discover_tests(compiler_test)
diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
index dde1626a..e4f3fea5 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -159,7 +159,7 @@ TEST_F(CompilerTest, Lists)
 
 TEST_F(CompilerTest, EmptyProject)
 {
-    ProjectPrivate p("empty_project.sb3", ScratchVersion::Scratch3);
+    ProjectPrivate p("empty_project.sb3");
     ASSERT_TRUE(p.load());
     auto engine = p.engine;
     ASSERT_EQ(engine->targets().size(), 1);
@@ -171,7 +171,7 @@ TEST_F(CompilerTest, EmptyProject)
 
 TEST_F(CompilerTest, ResolveIds)
 {
-    ProjectPrivate p("resolve_id_test.sb3", ScratchVersion::Scratch3);
+    ProjectPrivate p("resolve_id_test.sb3");
     ASSERT_TRUE(p.load());
     auto engine = p.engine;
     ASSERT_EQ(engine->targets().size(), 2);
@@ -300,6 +300,7 @@ TEST_F(CompilerTest, AddObscuredInput)
 
     compiler.addInstruction(vm::OP_HALT);
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2" }));
 }
 
 TEST_F(CompilerTest, AddNoShadowInput)
@@ -315,7 +316,8 @@ TEST_F(CompilerTest, AddNoShadowInput)
     compiler.addInstruction(vm::OP_PRINT);
 
     Input input2("TEST_INPUT2", Input::Type::NoShadow);
-    EXPECT_DEATH({ compiler.addInput(&input2); }, "(Assertion)([ ]+)(.+)([ ]+)(failed)");
+    input2.setPrimaryValue("test");
+    compiler.addInput(&input2);
 
     Input input3("TEST_INPUT3", Input::Type::NoShadow);
     std::shared_ptr<Block> block2 = std::make_shared<Block>("", "test_block2");
@@ -324,7 +326,17 @@ TEST_F(CompilerTest, AddNoShadowInput)
     compiler.addInstruction(vm::OP_PRINT);
 
     compiler.addInstruction(vm::OP_HALT);
-    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_CONST, 0, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues().size(), 1);
+    ASSERT_EQ(compiler.constValues()[0], "test");
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2" }));
+
+    Input input4("TEST_INPUT4", Input::Type::NoShadow);
+    std::shared_ptr<Block> block3 = std::make_shared<Block>("", "test_block3");
+    input4.setValueBlock(block3);
+    compiler.addInput(&input4);
+    compiler.addInstruction(vm::OP_PRINT);
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2", "test_block3" }));
 }
 
 TEST_F(CompilerTest, ResolveInput)
@@ -355,6 +367,7 @@ TEST_F(CompilerTest, ResolveDropdownMenuInput)
     auto block = std::make_shared<Block>("a", "test_block1");
     auto input = std::make_shared<Input>("INPUT1", Input::Type::Shadow);
     auto menu = std::make_shared<Block>("a", "test_menu");
+    menu->setShadow(true);
     auto optionField = std::make_shared<Field>("OPTION", "test");
     input->setInputId(TestBlockSection::INPUT1);
     input->setValueBlock(menu);
@@ -837,3 +850,26 @@ TEST_F(CompilerTest, EdgeActivatedHatPredicate)
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 1, vm::OP_PRINT, vm::OP_HALT }));
     ASSERT_EQ(compiler.constValues(), std::vector<Value>({ true, "test" }));
 }
+
+TEST_F(CompilerTest, UnsupportedBlocks)
+{
+    auto block1 = std::make_shared<Block>("b1", "block1");
+
+    auto block2 = std::make_shared<Block>("b2", "block2");
+    block2->setParent(block1);
+    block1->setNext(block2);
+
+    auto block3 = std::make_shared<Block>("b3", "block3");
+    block3->setCompileFunction([](Compiler *) {});
+    block3->setParent(block2);
+    block2->setNext(block3);
+
+    auto block4 = std::make_shared<Block>("b4", "block4");
+    block4->setParent(block3);
+    block3->setNext(block4);
+
+    INIT_COMPILER(engine, compiler);
+    compiler.compile(block1);
+
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "block1", "block2", "block4" }));
+}
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 5b8b6f96..86670a44 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -14,6 +14,7 @@
 #include <scratch/sound_p.h>
 #include <timermock.h>
 #include <clockmock.h>
+#include <audioenginemock.h>
 #include <audioinputmock.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
@@ -47,10 +48,11 @@ class RedrawMock
         MOCK_METHOD(void, redraw, ());
 };
 
-class ThreadAboutToStopMock
+class StopMock
 {
     public:
         MOCK_METHOD(void, threadRemoved, (VirtualMachine *));
+        MOCK_METHOD(void, stopped, ());
 };
 
 class AddRemoveMonitorMock
@@ -124,13 +126,13 @@ TEST(EngineTest, ClearThreadAboutToStopSignal)
     engine->start();
     engine->step();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     engine->clear();
 }
 
@@ -143,16 +145,50 @@ TEST(EngineTest, StopThreadAboutToStopSignal)
     engine->start();
     engine->step();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     engine->stop();
 }
 
+TEST(EngineTest, StopSignal)
+{
+    StopMock stopMock;
+
+    {
+        Project p("3_threads.sb3");
+        ASSERT_TRUE(p.load());
+        auto engine = p.engine();
+
+        engine->stopped().connect(&StopMock::stopped, &stopMock);
+        EXPECT_CALL(stopMock, stopped());
+        engine->start();
+        engine->step();
+
+        EXPECT_CALL(stopMock, stopped());
+        engine->stop();
+    }
+
+    {
+        Project p("stop_all_bypass.sb3");
+        ASSERT_TRUE(p.load());
+        auto engine = p.engine();
+
+        engine->stopped().connect(&StopMock::stopped, &stopMock);
+        EXPECT_CALL(stopMock, stopped());
+        engine->start();
+        EXPECT_CALL(stopMock, stopped());
+        engine->step();
+
+        EXPECT_CALL(stopMock, stopped());
+        engine->stop();
+    }
+}
+
 TEST(EngineTest, CompileAndExecuteMonitors)
 {
     Engine engine;
@@ -275,9 +311,7 @@ TEST(EngineTest, StopSounds)
 
     auto engine = p.engine();
 
-    EXPECT_CALL(*player1, isPlaying()).WillOnce(Return(false));
-    EXPECT_CALL(*player2, isPlaying()).WillOnce(Return(true));
-    EXPECT_CALL(*player3, isPlaying()).WillOnce(Return(true));
+    EXPECT_CALL(*player1, stop());
     EXPECT_CALL(*player2, stop());
     EXPECT_CALL(*player3, stop());
     engine->stopSounds();
@@ -285,6 +319,24 @@ TEST(EngineTest, StopSounds)
     SoundPrivate::audioOutput = nullptr;
 }
 
+TEST(EngineTest, GlobalVolume)
+{
+    Engine engine;
+    ASSERT_EQ(engine.globalVolume(), 100);
+
+    engine.setGlobalVolume(58.3);
+    ASSERT_EQ(std::round(engine.globalVolume() * 100) / 100, 58.3);
+
+    AudioEngineMock audioEngine;
+    engine.m_audioEngine = &audioEngine;
+
+    EXPECT_CALL(audioEngine, volume()).WillOnce(Return(0.275));
+    ASSERT_EQ(engine.globalVolume(), 27.5);
+
+    EXPECT_CALL(audioEngine, setVolume(0.9236));
+    engine.setGlobalVolume(92.36);
+}
+
 TEST(EngineTest, Step)
 {
     Project p("step.sb3");
@@ -827,7 +879,10 @@ TEST(EngineTest, MouseX)
     ASSERT_EQ(engine.mouseX(), 0);
 
     engine.setMouseX(-128.038);
-    ASSERT_EQ(engine.mouseX(), -128.038);
+    ASSERT_EQ(engine.mouseX(), -128);
+
+    engine.setMouseX(35.7);
+    ASSERT_EQ(engine.mouseX(), 36);
 }
 
 TEST(EngineTest, MouseY)
@@ -835,8 +890,11 @@ TEST(EngineTest, MouseY)
     Engine engine;
     ASSERT_EQ(engine.mouseY(), 0);
 
-    engine.setMouseY(179.9258);
-    ASSERT_EQ(engine.mouseY(), 179.9258);
+    engine.setMouseY(179.1258);
+    ASSERT_EQ(engine.mouseY(), 179);
+
+    engine.setMouseY(-12.98);
+    ASSERT_EQ(engine.mouseY(), -13);
 }
 
 TEST(EngineTest, MousePressed)
@@ -1218,21 +1276,25 @@ TEST(EngineTest, Broadcasts)
     auto b1 = std::make_shared<Broadcast>("a", "message1");
     auto b2 = std::make_shared<Broadcast>("b", "message2");
     auto b3 = std::make_shared<Broadcast>("c", "Test");
-    engine.setBroadcasts({ b1, b2, b3 });
+    auto b4 = std::make_shared<Broadcast>("d", "TesT");
+    engine.setBroadcasts({ b1, b2, b3, b4 });
 
-    ASSERT_EQ(engine.broadcasts(), std::vector<std::shared_ptr<Broadcast>>({ b1, b2, b3 }));
+    ASSERT_EQ(engine.broadcasts(), std::vector<std::shared_ptr<Broadcast>>({ b1, b2, b3, b4 }));
     ASSERT_EQ(engine.broadcastAt(0), b1);
     ASSERT_EQ(engine.broadcastAt(1), b2);
     ASSERT_EQ(engine.broadcastAt(2), b3);
-    ASSERT_EQ(engine.broadcastAt(3), nullptr);
+    ASSERT_EQ(engine.broadcastAt(3), b4);
+    ASSERT_EQ(engine.broadcastAt(4), nullptr);
     ASSERT_EQ(engine.broadcastAt(-1), nullptr);
 
-    ASSERT_EQ(engine.findBroadcast("invalid"), -1);
-    ASSERT_EQ(engine.findBroadcast("message1"), 0);
-    ASSERT_EQ(engine.findBroadcast("message2"), 1);
-    ASSERT_EQ(engine.findBroadcast("Test"), 2);
+    ASSERT_TRUE(engine.findBroadcasts("invalid").empty());
+    ASSERT_EQ(engine.findBroadcasts("message1"), std::vector<int>({ 0 }));
+    ASSERT_EQ(engine.findBroadcasts("message2"), std::vector<int>({ 1 }));
+    ASSERT_EQ(engine.findBroadcasts("Test"), std::vector<int>({ 2, 3 }));
+    ASSERT_EQ(engine.findBroadcasts("MessAge2"), std::vector<int>({ 1 }));
+    ASSERT_EQ(engine.findBroadcasts("tEst"), std::vector<int>({ 2, 3 }));
 
-    ASSERT_EQ(engine.findBroadcastById("d"), -1);
+    ASSERT_EQ(engine.findBroadcastById("e"), -1);
     ASSERT_EQ(engine.findBroadcastById("a"), 0);
     ASSERT_EQ(engine.findBroadcastById("b"), 1);
     ASSERT_EQ(engine.findBroadcastById("c"), 2);
@@ -1890,13 +1952,13 @@ TEST(EngineTest, BroadcastsProject)
 
     auto engine = p.engine();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(21).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(21).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     engine->setFps(1000);
     p.run();
 
@@ -1938,13 +2000,13 @@ TEST(EngineTest, StopAllBypass)
 
     auto engine = p.engine();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(2).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(2).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     p.run();
 
     Stage *stage = engine->stage();
@@ -1966,13 +2028,13 @@ TEST(EngineTest, StopOtherScriptsInSprite)
 
     auto engine = p.engine();
 
-    ThreadAboutToStopMock threadRemovedMock;
-    EXPECT_CALL(threadRemovedMock, threadRemoved(_)).Times(4).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    StopMock stopMock;
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(4).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
         ASSERT_TRUE(vm);
         ASSERT_FALSE(vm->atEnd());
     })));
 
-    engine->threadAboutToStop().connect(&ThreadAboutToStopMock::threadRemoved, &threadRemovedMock);
+    engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
     p.run();
 
     Stage *stage = engine->stage();
@@ -2071,6 +2133,15 @@ TEST(EngineTest, UserAgent)
     ASSERT_EQ(engine.userAgent(), "test");
 }
 
+TEST(EngineTest, UnsupportedBlocks)
+{
+    Project p("unsupported_blocks.sb3");
+    ASSERT_TRUE(p.load());
+    ASSERT_EQ(
+        p.engine()->unsupportedBlocks(),
+        std::unordered_set<std::string>({ "ev3_motorTurnClockwise", "ev3_motorSetPower", "ev3_getMotorPosition", "ev3_whenButtonPressed", "ev3_getBrightness", "ev3_getDistance" }));
+}
+
 TEST(EngineTest, NoCrashAfterStop)
 {
     // Regtest for #186
@@ -2245,3 +2316,37 @@ TEST(EngineTest, NoCrashWithUndefinedVariableOrList)
     ASSERT_EQ(list->id(), "}l+w#Er5y!:*gh~5!3t%");
     ASSERT_TRUE(list->empty());
 }
+
+TEST(EngineTest, AlwaysStopCloneThreads)
+{
+    // Regtest for #547
+    Project p("regtest_projects/547_stop_clone_threads_in_stop_all.sb3");
+    ASSERT_TRUE(p.load());
+
+    auto engine = p.engine();
+
+    Stage *stage = engine->stage();
+    ASSERT_TRUE(stage);
+
+    engine->run();
+
+    ASSERT_VAR(stage, "test");
+    ASSERT_EQ(GET_VAR(stage, "test")->value().toInt(), 0);
+}
+
+TEST(EngineTest, DuplicateVariableOrListIDs)
+{
+    // Regtest for #567
+    Project p("regtest_projects/567_duplicate_variable_list_id.sb3");
+    ASSERT_TRUE(p.load());
+
+    auto engine = p.engine();
+
+    Stage *stage = engine->stage();
+    ASSERT_TRUE(stage);
+
+    engine->run();
+
+    ASSERT_VAR(stage, "passed");
+    ASSERT_TRUE(GET_VAR(stage, "passed")->value().toBool());
+}
diff --git a/test/load_project/load_project_test.cpp b/test/load_project/load_project_test.cpp
index 827884e5..1830b446 100644
--- a/test/load_project/load_project_test.cpp
+++ b/test/load_project/load_project_test.cpp
@@ -22,7 +22,6 @@
 
 using namespace libscratchcpp;
 
-static const std::vector<ScratchVersion> scratchVersions = { ScratchVersion::Scratch3 };
 static const std::vector<std::string> fileExtensions = { ".sb3" };
 
 using ::testing::Return;
@@ -31,8 +30,8 @@ using ::testing::ReturnRef;
 TEST(LoadProjectTest, EmptyProject)
 {
     int i = 0;
-    for (auto version : scratchVersions) {
-        Project p("empty_project" + fileExtensions[i], version);
+    for (auto ext : fileExtensions) {
+        Project p("empty_project" + ext);
 
         ASSERT_TRUE(p.load());
 
@@ -99,11 +98,6 @@ TEST(LoadProjectTest, DownloadDefaultProject)
     };
     static const std::vector<std::string> assetData = { "a", "b", "c", "d", "e" };
 
-    EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(true));
-    EXPECT_CALL(*downloader, json()).WillOnce(ReturnRef(data));
-    p.detectScratchVersion();
-    ASSERT_EQ(p.scratchVersion, ScratchVersion::Scratch3);
-
     EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(true));
     EXPECT_CALL(*downloader, json()).WillOnce(ReturnRef(data));
     EXPECT_CALL(*downloader, downloadAssets(assets)).WillOnce(Return(true));
@@ -168,15 +162,8 @@ TEST(LoadProjectTest, DownloadDefaultProjectFailure)
     static const std::vector<std::string> assetData = { "a", "b", "c", "d", "e" };
 
     EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(false));
-    p.detectScratchVersion();
-    ASSERT_EQ(p.scratchVersion, ScratchVersion::Invalid);
     ASSERT_FALSE(p.load());
 
-    EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(true));
-    EXPECT_CALL(*downloader, json()).WillOnce(ReturnRef(data));
-    p.detectScratchVersion();
-    ASSERT_EQ(p.scratchVersion, ScratchVersion::Scratch3);
-
     EXPECT_CALL(*downloader, downloadJson("ABCDEFGH")).WillOnce(Return(false));
     ASSERT_FALSE(p.load());
 
@@ -195,8 +182,8 @@ TEST(LoadProjectTest, DownloadDefaultProjectFailure)
 TEST(LoadProjectTest, LoadTestProject)
 {
     int i = 0;
-    for (auto version : scratchVersions) {
-        Project p("load_test" + fileExtensions[i], version);
+    for (auto ext : fileExtensions) {
+        Project p("load_test" + ext);
 
         ASSERT_TRUE(p.load());
 
@@ -241,7 +228,7 @@ TEST(LoadProjectTest, LoadTestProject)
         ASSERT_EQ(sprite1->name(), "Sprite1");
         ASSERT_EQ(sprite1->variables().size(), 1);
         ASSERT_EQ(sprite1->lists().size(), 1);
-        ASSERT_EQ(sprite1->blocks().size(), 18);
+        ASSERT_EQ(sprite1->blocks().size(), 19);
         ASSERT_EQ(sprite1->costumes().size(), 2);
         ASSERT_EQ(sprite1->comments().size(), 1);
         ASSERT_EQ(sprite1->costumeIndex(), 1);
@@ -291,6 +278,8 @@ TEST(LoadProjectTest, LoadTestProject)
         ASSERT_TRUE(sprite1->greenFlagBlocks()[0]);
         ASSERT_FALSE(sprite1->greenFlagBlocks()[0]->isTopLevelReporter());
         ASSERT_EQ(sprite1->greenFlagBlocks()[0]->opcode(), "event_whenflagclicked");
+        ASSERT_EQ(sprite1->greenFlagBlocks()[0]->x(), 0);
+        ASSERT_EQ(sprite1->greenFlagBlocks()[0]->y(), 0);
         auto block = sprite1->greenFlagBlocks()[0]->next();
         ASSERT_TRUE(block);
         ASSERT_EQ(block->parent(), sprite1->greenFlagBlocks()[0]);
@@ -356,6 +345,8 @@ TEST(LoadProjectTest, LoadTestProject)
             }
         }
         ASSERT_TRUE(defineBlock);
+        ASSERT_EQ(defineBlock->x(), 0);
+        ASSERT_EQ(defineBlock->y(), 384);
         ASSERT_INPUT(defineBlock, "custom_block");
         auto blockPrototype = GET_INPUT(defineBlock, "custom_block")->valueBlock();
         ASSERT_TRUE(blockPrototype);
@@ -385,6 +376,17 @@ TEST(LoadProjectTest, LoadTestProject)
         ASSERT_TRUE(argBlock);
         ASSERT_EQ(argBlock->opcode(), "argument_reporter_string_number");
 
+        std::shared_ptr<Block> keyPressedBlock = nullptr;
+        for (auto b : blocks) {
+            if (b->opcode() == "event_whenkeypressed") {
+                keyPressedBlock = b;
+                break;
+            }
+        }
+        ASSERT_TRUE(keyPressedBlock);
+        ASSERT_EQ(keyPressedBlock->x(), 488);
+        ASSERT_EQ(keyPressedBlock->y(), 152);
+
         // Balloon1
         ASSERT_NE(engine->findTarget("Balloon1"), -1);
         Sprite *sprite2 = dynamic_cast<Sprite *>(engine->targetAt(engine->findTarget("Balloon1")));
@@ -647,8 +649,8 @@ TEST(LoadProjectTest, LoadTestProject)
 TEST(LoadProjectTest, LoadTopLevelReporterProject)
 {
     int i = 0;
-    for (auto version : scratchVersions) {
-        Project p("top_level_reporter" + fileExtensions[i], version);
+    for (auto ext : fileExtensions) {
+        Project p("top_level_reporter" + ext);
 
         ASSERT_TRUE(p.load());
 
@@ -664,6 +666,8 @@ TEST(LoadProjectTest, LoadTopLevelReporterProject)
         auto block1 = sprite1->blockAt(0);
         ASSERT_TRUE(block1);
         ASSERT_TRUE(block1->isTopLevelReporter());
+        ASSERT_EQ(block1->x(), 335);
+        ASSERT_EQ(block1->y(), 335);
         InputValue *reporterInfo = block1->topLevelReporterInfo();
         ASSERT_TRUE(reporterInfo);
         ASSERT_EQ(reporterInfo->type(), InputValue::Type::Variable);
@@ -674,6 +678,8 @@ TEST(LoadProjectTest, LoadTopLevelReporterProject)
         auto block2 = sprite1->blockAt(1);
         ASSERT_TRUE(block2);
         ASSERT_TRUE(block2->isTopLevelReporter());
+        ASSERT_EQ(block2->x(), 313);
+        ASSERT_EQ(block2->y(), 435);
         reporterInfo = block2->topLevelReporterInfo();
         ASSERT_TRUE(reporterInfo);
         ASSERT_EQ(reporterInfo->type(), InputValue::Type::List);
@@ -688,11 +694,10 @@ TEST(LoadProjectTest, LoadTopLevelReporterProject)
 TEST(LoadProjectTest, ProjectTest)
 {
     int i = 0;
-    for (auto version : scratchVersions) {
-        std::string name = "load_test" + fileExtensions[i];
-        Project p(name, version);
+    for (auto ext : fileExtensions) {
+        std::string name = "load_test" + ext;
+        Project p(name);
         ASSERT_EQ(p.fileName(), name);
-        ASSERT_EQ(p.scratchVersion(), version);
         ASSERT_TRUE(p.load());
 
         auto engine = p.engine();
@@ -709,15 +714,6 @@ TEST(LoadProjectTest, ProjectTest)
     }
 }
 
-TEST(LoadProjectTest, ProjectInvalidTest)
-{
-    std::string name = "load_test.sb3";
-    Project p(name, ScratchVersion::Invalid);
-    ASSERT_EQ(p.fileName(), name);
-    ASSERT_EQ(p.scratchVersion(), ScratchVersion::Invalid);
-    ASSERT_FALSE(p.load());
-}
-
 TEST(LoadProjectTest, LoadNullDimensionMonitor)
 {
     // Regtest for #448
diff --git a/test/load_test.sb3 b/test/load_test.sb3
index d1553e8e..eeaa571f 100644
Binary files a/test/load_test.sb3 and b/test/load_test.sb3 differ
diff --git a/test/mocks/audioenginemock.h b/test/mocks/audioenginemock.h
new file mode 100644
index 00000000..6d7c9003
--- /dev/null
+++ b/test/mocks/audioenginemock.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <audio/iaudioengine.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class AudioEngineMock : public IAudioEngine
+{
+    public:
+        MOCK_METHOD(float, volume, (), (const, override));
+        MOCK_METHOD(void, setVolume, (float), (override));
+};
diff --git a/test/mocks/audioplayermock.h b/test/mocks/audioplayermock.h
index 893e6b10..6116ad37 100644
--- a/test/mocks/audioplayermock.h
+++ b/test/mocks/audioplayermock.h
@@ -14,6 +14,12 @@ class AudioPlayerMock : public IAudioPlayer
         MOCK_METHOD(float, volume, (), (const, override));
         MOCK_METHOD(void, setVolume, (float), (override));
 
+        MOCK_METHOD(float, pitch, (), (const, override));
+        MOCK_METHOD(void, setPitch, (float), (override));
+
+        MOCK_METHOD(float, pan, (), (const, override));
+        MOCK_METHOD(void, setPan, (float), (override));
+
         MOCK_METHOD(bool, isLoaded, (), (const, override));
 
         MOCK_METHOD(void, start, (), (override));
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 1a3d67ee..deddb32f 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -17,14 +17,17 @@ 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), (override));
+        MOCK_METHOD(void, broadcast, (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));
         MOCK_METHOD(void, deinitClone, (std::shared_ptr<Sprite>), (override));
+
         MOCK_METHOD(void, stopSounds, (), (override));
+        MOCK_METHOD(double, globalVolume, (), (const, override));
+        MOCK_METHOD(void, setGlobalVolume, (double), (override));
 
         MOCK_METHOD(void, updateMonitors, (), (override));
         MOCK_METHOD(void, step, (), (override));
@@ -34,6 +37,7 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(sigslot::signal<> &, aboutToRender, (), (override));
         MOCK_METHOD(sigslot::signal<VirtualMachine *> &, threadAboutToStop, (), (override));
+        MOCK_METHOD(sigslot::signal<> &, stopped, (), (override));
 
         MOCK_METHOD(bool, isRunning, (), (const, override));
 
@@ -99,9 +103,10 @@ class EngineMock : public IEngine
         MOCK_METHOD(const std::vector<std::shared_ptr<Broadcast>> &, broadcasts, (), (const, override));
         MOCK_METHOD(void, setBroadcasts, (const std::vector<std::shared_ptr<Broadcast>> &), (override));
         MOCK_METHOD(std::shared_ptr<Broadcast>, broadcastAt, (int), (const, override));
-        MOCK_METHOD(int, findBroadcast, (const std::string &), (const, override));
+        MOCK_METHOD(std::vector<int>, findBroadcasts, (const std::string &), (const, override));
         MOCK_METHOD(int, findBroadcastById, (const std::string &), (const, override));
 
+        MOCK_METHOD(void, addWhenTouchingObjectScript, (std::shared_ptr<Block>), (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));
@@ -129,6 +134,7 @@ class EngineMock : public IEngine
         MOCK_METHOD((sigslot::signal<Monitor *, IMonitorHandler *> &), monitorRemoved, (), (override));
 
         MOCK_METHOD(sigslot::signal<const std::string &> &, questionAsked, (), (override));
+        MOCK_METHOD(sigslot::signal<> &, questionAborted, (), (override));
         MOCK_METHOD(sigslot::signal<const std::string &> &, questionAnswered, (), (override));
 
         MOCK_METHOD(std::vector<std::string> &, extensions, (), (const, override));
@@ -138,6 +144,8 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(const std::string &, userAgent, (), (const, override));
         MOCK_METHOD(void, setUserAgent, (const std::string &), (override));
+
+        MOCK_METHOD(const std::unordered_set<std::string> &, unsupportedBlocks, (), (const, override));
 };
 
 } // namespace libscratchcpp
diff --git a/test/mocks/soundmock.h b/test/mocks/soundmock.h
new file mode 100644
index 00000000..63c9526f
--- /dev/null
+++ b/test/mocks/soundmock.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <scratchcpp/sound.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class SoundMock : public Sound
+{
+    public:
+        SoundMock() :
+            Sound("", "", "")
+        {
+        }
+
+        MOCK_METHOD(void, setVolume, (double), (override));
+        MOCK_METHOD(void, setEffect, (Sound::Effect, double), (override));
+
+        MOCK_METHOD(void, start, (), (override));
+        MOCK_METHOD(void, stop, (), (override));
+        MOCK_METHOD(bool, isPlaying, (), (const, override));
+};
diff --git a/test/mocks/spritehandlermock.h b/test/mocks/spritehandlermock.h
index 14bb30f8..d944f807 100644
--- a/test/mocks/spritehandlermock.h
+++ b/test/mocks/spritehandlermock.h
@@ -29,6 +29,9 @@ class SpriteHandlerMock : public ISpriteHandler
         MOCK_METHOD(void, onBubbleTypeChanged, (Target::BubbleType), (override));
         MOCK_METHOD(void, onBubbleTextChanged, (const std::string &), (override));
 
+        MOCK_METHOD(int, costumeWidth, (), (const, override));
+        MOCK_METHOD(int, costumeHeight, (), (const, override));
+
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
         MOCK_METHOD(Rect, fastBoundingRect, (), (const, override));
 
diff --git a/test/mocks/stagehandlermock.h b/test/mocks/stagehandlermock.h
index a060ac3d..a7e15055 100644
--- a/test/mocks/stagehandlermock.h
+++ b/test/mocks/stagehandlermock.h
@@ -20,6 +20,9 @@ class StageHandlerMock : public IStageHandler
         MOCK_METHOD(void, onBubbleTypeChanged, (Target::BubbleType), (override));
         MOCK_METHOD(void, onBubbleTextChanged, (const std::string &), (override));
 
+        MOCK_METHOD(int, costumeWidth, (), (const, override));
+        MOCK_METHOD(int, costumeHeight, (), (const, override));
+
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
         MOCK_METHOD(Rect, fastBoundingRect, (), (const, override));
 
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
index 2ca5140d..5df18e09 100644
--- a/test/mocks/targetmock.h
+++ b/test/mocks/targetmock.h
@@ -11,8 +11,17 @@ class TargetMock : public Target
         MOCK_METHOD(bool, isStage, (), (const, override));
 
         MOCK_METHOD(void, setCostumeIndex, (int), (override));
+
+        MOCK_METHOD(int, currentCostumeWidth, (), (const, override));
+        MOCK_METHOD(int, currentCostumeHeight, (), (const, override));
+
         MOCK_METHOD(void, setLayerOrder, (int), (override));
 
+        MOCK_METHOD(double, soundEffectValue, (Sound::Effect), (const, override));
+        MOCK_METHOD(void, setSoundEffectValue, (Sound::Effect, double), (override));
+
+        MOCK_METHOD(void, clearSoundEffects, (), (override));
+
         MOCK_METHOD(Rect, boundingRect, (), (const, override));
         MOCK_METHOD(Rect, fastBoundingRect, (), (const, override));
 
diff --git a/test/network/projectdownloader_test.cpp b/test/network/projectdownloader_test.cpp
index acda894d..25359160 100644
--- a/test/network/projectdownloader_test.cpp
+++ b/test/network/projectdownloader_test.cpp
@@ -75,51 +75,4 @@ TEST_F(ProjectDownloaderTest, DownloadJson)
     ASSERT_EQ(m_downloader->downloadedAssetCount(), 0);
 }
 
-TEST_F(ProjectDownloaderTest, DownloadAssets)
-{
-    static const std::string assetPrefix = "https://assets.scratch.mit.edu/internalapi/asset/";
-    static const std::string assetSuffix = "/get";
-    static const std::vector<std::string> assetIds = { "abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yzA", "BCD", "EFG", "HIJ", "KLM", "NOP", "QRS", "TUV", "WXY" };
-    static const std::vector<std::string> assetData = { "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15", "a16", "a17" };
-    ASSERT_EQ(assetIds.size(), assetData.size());
-    std::vector<std::shared_ptr<DownloaderMock>> downloaders;
-    std::vector<unsigned int> downloaderTextIndexes;
-    unsigned int threadCount = std::thread::hardware_concurrency();
-    threadCount = std::max(1u, std::min(threadCount, static_cast<unsigned int>(std::ceil(assetIds.size() / 5.0))));
-
-    downloaders.reserve(threadCount);
-    downloaderTextIndexes.reserve(threadCount);
-
-    for (unsigned int i = 0; i < threadCount; i++) {
-        downloaders.push_back(std::make_shared<DownloaderMock>());
-        downloaderTextIndexes.push_back(0);
-    }
-
-    // Success
-    unsigned int count = 0;
-    EXPECT_CALL(*m_factory, create()).Times(threadCount);
-    ON_CALL(*m_factory, create()).WillByDefault(Invoke([&downloaders, &count]() {
-        assert(count < downloaders.size());
-        return downloaders[count++];
-    }));
-
-    for (unsigned int i = 0; i < threadCount; i++)
-        downloaderTextIndexes[i] = 0;
-
-    for (unsigned int i = 0; i < threadCount; i++) {
-        auto downloader = downloaders[i];
-        unsigned int n = std::ceil(assetIds.size() / static_cast<double>(threadCount));
-        unsigned int repeatCount = std::min(n, static_cast<unsigned int>(assetIds.size()) - i * n);
-
-        for (unsigned int j = 0; j < repeatCount; j++) {
-            unsigned int index = i * n + j;
-            EXPECT_CALL(*downloader, download(assetPrefix + assetIds[index] + assetSuffix)).WillOnce(Return(true));
-        }
-
-        EXPECT_CALL(*downloader, text()).Times(repeatCount).WillRepeatedly(Invoke([i, n, &downloaderTextIndexes]() -> const std::string & { return assetData[i * n + downloaderTextIndexes[i]++]; }));
-    }
-
-    ASSERT_TRUE(m_downloader->downloadAssets(assetIds));
-    ASSERT_EQ(m_downloader->assets(), assetData);
-    ASSERT_EQ(m_downloader->downloadedAssetCount(), assetIds.size());
-}
+// NOTE: Asset downloading should be tested manually
diff --git a/test/project/project_test.cpp b/test/project/project_test.cpp
index c4346a22..93f350f2 100644
--- a/test/project/project_test.cpp
+++ b/test/project/project_test.cpp
@@ -24,35 +24,16 @@ TEST_F(ProjectTest, Constructors)
     // Constructor 1
     Project p1;
     ASSERT_EQ(p1.fileName(), "");
-    ASSERT_EQ(p1.scratchVersion(), ScratchVersion::Invalid);
     ASSERT_TRUE(p1.engine());
 
     // Constructor 2
     Project p2("nonexistent.sb3");
     ASSERT_EQ(p2.fileName(), "nonexistent.sb3");
-    ASSERT_EQ(p2.scratchVersion(), ScratchVersion::Invalid);
     ASSERT_TRUE(p2.engine());
 
     Project p3("default_project.sb3");
     ASSERT_EQ(p3.fileName(), "default_project.sb3");
-    ASSERT_EQ(p3.scratchVersion(), ScratchVersion::Scratch3);
     ASSERT_TRUE(p3.engine());
-
-    // Constructor 3
-    Project p4("nonexistent.sb3", ScratchVersion::Scratch3);
-    ASSERT_EQ(p4.fileName(), "nonexistent.sb3");
-    ASSERT_EQ(p4.scratchVersion(), ScratchVersion::Scratch3);
-    ASSERT_TRUE(p4.engine());
-
-    Project p5("default_project.sb3", ScratchVersion::Scratch3);
-    ASSERT_EQ(p5.fileName(), "default_project.sb3");
-    ASSERT_EQ(p5.scratchVersion(), ScratchVersion::Scratch3);
-    ASSERT_TRUE(p5.engine());
-
-    Project p6("default_project.sb3", ScratchVersion::Invalid);
-    ASSERT_EQ(p6.fileName(), "default_project.sb3");
-    ASSERT_EQ(p6.scratchVersion(), ScratchVersion::Invalid);
-    ASSERT_TRUE(p6.engine());
 }
 
 TEST_F(ProjectTest, Load)
@@ -89,37 +70,6 @@ TEST_F(ProjectTest, Load)
     EXPECT_CALL(*m_engine, compile).Times(1);
     ASSERT_TRUE(p3.load());
 
-    // Constructor 3
-    ProjectPrivate p4("nonexistent.sb3", ScratchVersion::Scratch3);
-    p4.engine = m_engine;
-    EXPECT_CALL(*m_engine, clear).Times(0);
-    EXPECT_CALL(*m_engine, setTargets).Times(0);
-    EXPECT_CALL(*m_engine, setBroadcasts).Times(0);
-    EXPECT_CALL(*m_engine, setMonitors).Times(0);
-    EXPECT_CALL(*m_engine, setExtensions).Times(0);
-    EXPECT_CALL(*m_engine, compile).Times(0);
-    ASSERT_FALSE(p4.load());
-
-    ProjectPrivate p5("default_project.sb3", ScratchVersion::Scratch3);
-    p5.engine = m_engine;
-    EXPECT_CALL(*m_engine, clear).Times(1);
-    EXPECT_CALL(*m_engine, setTargets).Times(1);
-    EXPECT_CALL(*m_engine, setBroadcasts).Times(1);
-    EXPECT_CALL(*m_engine, setMonitors).Times(1);
-    EXPECT_CALL(*m_engine, setExtensions).Times(1);
-    EXPECT_CALL(*m_engine, compile).Times(1);
-    ASSERT_TRUE(p5.load());
-
-    ProjectPrivate p6("default_project.sb3", ScratchVersion::Invalid);
-    p6.engine = m_engine;
-    EXPECT_CALL(*m_engine, clear).Times(0);
-    EXPECT_CALL(*m_engine, setTargets).Times(0);
-    EXPECT_CALL(*m_engine, setBroadcasts).Times(0);
-    EXPECT_CALL(*m_engine, setMonitors).Times(0);
-    EXPECT_CALL(*m_engine, setExtensions).Times(0);
-    EXPECT_CALL(*m_engine, compile).Times(0);
-    ASSERT_FALSE(p6.load());
-
     testing::Mock::AllowLeak(m_engine.get());
 }
 
@@ -146,17 +96,9 @@ TEST_F(ProjectTest, FileName)
     Project p;
     p.setFileName("test.sb3");
     ASSERT_EQ(p.fileName(), "test.sb3");
-    ASSERT_EQ(p.scratchVersion(), ScratchVersion::Invalid);
 
     p.setFileName("default_project.sb3");
-    ASSERT_EQ(p.scratchVersion(), ScratchVersion::Scratch3);
-}
-
-TEST_F(ProjectTest, ScratchVersion)
-{
-    Project p;
-    p.setScratchVersion(ScratchVersion::Scratch3);
-    ASSERT_EQ(p.scratchVersion(), ScratchVersion::Scratch3);
+    ASSERT_EQ(p.fileName(), "default_project.sb3");
 }
 
 TEST(LoadProjectTest, DownloadProgressChanged)
diff --git a/test/regtest_projects/547_stop_clone_threads_in_stop_all.sb3 b/test/regtest_projects/547_stop_clone_threads_in_stop_all.sb3
new file mode 100644
index 00000000..455831d1
Binary files /dev/null and b/test/regtest_projects/547_stop_clone_threads_in_stop_all.sb3 differ
diff --git a/test/regtest_projects/567_duplicate_variable_list_id.sb3 b/test/regtest_projects/567_duplicate_variable_list_id.sb3
new file mode 100644
index 00000000..f93d7535
Binary files /dev/null and b/test/regtest_projects/567_duplicate_variable_list_id.sb3 differ
diff --git a/test/scratch_classes/block_test.cpp b/test/scratch_classes/block_test.cpp
index 905f5c64..a0b4545c 100644
--- a/test/scratch_classes/block_test.cpp
+++ b/test/scratch_classes/block_test.cpp
@@ -194,6 +194,24 @@ TEST_F(BlockTest, TopLevel)
     ASSERT_TRUE(block.topLevel());
 }
 
+TEST_F(BlockTest, X)
+{
+    Block block("", "");
+    ASSERT_EQ(block.x(), 0);
+
+    block.setX(12);
+    ASSERT_EQ(block.x(), 12);
+}
+
+TEST_F(BlockTest, Y)
+{
+    Block block("", "");
+    ASSERT_EQ(block.y(), 0);
+
+    block.setY(8);
+    ASSERT_EQ(block.y(), 8);
+}
+
 TEST_F(BlockTest, Comment)
 {
     Block block("", "");
diff --git a/test/scratch_classes/input_test.cpp b/test/scratch_classes/input_test.cpp
index ac8ca86f..48eb659f 100644
--- a/test/scratch_classes/input_test.cpp
+++ b/test/scratch_classes/input_test.cpp
@@ -81,6 +81,10 @@ TEST(InputTest, SelectedMenuItem)
 
     auto field1 = std::make_shared<Field>("OPTION1", "");
     block1->addField(field1);
+    ASSERT_FALSE(input1.pointsToDropdownMenu());
+    ASSERT_TRUE(input1.selectedMenuItem().empty());
+
+    block1->setShadow(true);
     ASSERT_TRUE(input1.pointsToDropdownMenu());
     ASSERT_TRUE(input1.selectedMenuItem().empty());
 
@@ -90,6 +94,7 @@ TEST(InputTest, SelectedMenuItem)
     ASSERT_TRUE(input1.selectedMenuItem().empty());
 
     auto block2 = std::make_shared<Block>("def", "");
+    block2->setShadow(true);
     input1.setValueBlock(block2);
 
     field1 = std::make_shared<Field>("OPTION1", "something");
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index c2f11ed9..ea79c577 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -400,6 +400,12 @@ TEST(SpriteTest, Dragging)
     sprite.setInterface(&handler);
     ASSERT_FALSE(sprite.dragging());
 
+    EngineMock engine;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, spriteFencingEnabled).WillRepeatedly(Return(false));
+    EXPECT_CALL(engine, requestRedraw).WillRepeatedly(Return());
+
+    EXPECT_CALL(engine, moveSpriteToFront(&sprite));
     sprite.startDragging();
     ASSERT_TRUE(sprite.dragging());
 
@@ -448,21 +454,43 @@ TEST(SpriteTest, Dragging)
 TEST(SpriteTest, Size)
 {
     Sprite sprite;
+    SpriteHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    sprite.setInterface(&handler);
     ASSERT_EQ(sprite.size(), 100);
 
     EngineMock engine;
     sprite.setEngine(&engine);
-    EXPECT_CALL(engine, requestRedraw()).Times(4);
+    EXPECT_CALL(engine, requestRedraw()).WillRepeatedly(Return());
+    EXPECT_CALL(engine, stageWidth()).WillRepeatedly(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillRepeatedly(Return(360));
+    EXPECT_CALL(handler, onSizeChanged).WillRepeatedly(Return());
 
+    EXPECT_CALL(handler, costumeWidth()).WillRepeatedly(Return(50));
+    EXPECT_CALL(handler, costumeHeight()).WillRepeatedly(Return(30));
     sprite.setSize(63.724);
     ASSERT_EQ(sprite.size(), 63.724);
-
-    sprite.setCostumeIndex(1);
+    sprite.setSize(0);
+    ASSERT_EQ(std::round(sprite.size() * 100) / 100, 16.67);
+    sprite.setSize(2000);
+    ASSERT_EQ(sprite.size(), 1440);
+
+    EXPECT_CALL(handler, costumeWidth()).WillRepeatedly(Return(30));
+    EXPECT_CALL(handler, costumeHeight()).WillRepeatedly(Return(50));
+    sprite.setSize(0);
+    ASSERT_EQ(std::round(sprite.size() * 100) / 100, 16.67);
+    sprite.setSize(2000);
+    ASSERT_EQ(sprite.size(), 1080);
+
+    EXPECT_CALL(handler, costumeWidth()).WillRepeatedly(Return(88));
+    EXPECT_CALL(handler, costumeHeight()).WillRepeatedly(Return(88));
+    sprite.setSize(0);
+    ASSERT_EQ(std::round(sprite.size() * 100) / 100, 5.68);
+    sprite.setSize(2000);
+    ASSERT_EQ(std::round(sprite.size() * 100) / 100, 613.64);
 
     sprite.setSize(186.84);
     ASSERT_EQ(sprite.size(), 186.84);
-
-    sprite.setCostumeIndex(0);
 }
 
 TEST(SpriteTest, CostumeIndex)
@@ -662,6 +690,28 @@ TEST(SpriteTest, KeepInFence)
     ASSERT_EQ(std::round(fencedY * 100) / 100, 150.9);
 }
 
+TEST(SpriteTest, CurrentCostumeWidth)
+{
+    Sprite sprite;
+    SpriteHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    sprite.setInterface(&handler);
+
+    EXPECT_CALL(handler, costumeWidth()).WillOnce(Return(46));
+    ASSERT_EQ(sprite.currentCostumeWidth(), 46);
+}
+
+TEST(SpriteTest, CurrentCostumeHeight)
+{
+    Sprite sprite;
+    SpriteHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    sprite.setInterface(&handler);
+
+    EXPECT_CALL(handler, costumeHeight()).WillOnce(Return(24));
+    ASSERT_EQ(sprite.currentCostumeHeight(), 24);
+}
+
 TEST(SpriteTest, DefaultBoundingRect)
 {
     Sprite sprite;
diff --git a/test/scratch_classes/stage_test.cpp b/test/scratch_classes/stage_test.cpp
index 4418d06f..78d3763b 100644
--- a/test/scratch_classes/stage_test.cpp
+++ b/test/scratch_classes/stage_test.cpp
@@ -137,6 +137,28 @@ TEST(StageTest, DefaultBoundingRect)
     ASSERT_EQ(rect.bottom(), 0);
 }
 
+TEST(StageTest, CurrentCostumeWidth)
+{
+    Stage stage;
+    StageHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    stage.setInterface(&handler);
+
+    EXPECT_CALL(handler, costumeWidth()).WillOnce(Return(46));
+    ASSERT_EQ(stage.currentCostumeWidth(), 46);
+}
+
+TEST(StageTest, CurrentCostumeHeight)
+{
+    Stage stage;
+    StageHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    stage.setInterface(&handler);
+
+    EXPECT_CALL(handler, costumeHeight()).WillOnce(Return(24));
+    ASSERT_EQ(stage.currentCostumeHeight(), 24);
+}
+
 TEST(StageTest, DefaultFastBoundingRect)
 {
     Stage stage;
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index 7c521da5..e71771d2 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -13,6 +13,7 @@
 #include <graphicseffectmock.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
+#include <soundmock.h>
 
 #include "../common.h"
 
@@ -442,6 +443,10 @@ TEST(TargetTest, Sounds)
     ASSERT_EQ(target.findSound("sound2"), 1);
     ASSERT_EQ(target.findSound("sound3"), 2);
 
+    ASSERT_EQ(s1->target(), &target);
+    ASSERT_EQ(s2->target(), &target);
+    ASSERT_EQ(s3->target(), &target);
+
     SoundPrivate::audioOutput = nullptr;
 }
 
@@ -507,6 +512,68 @@ TEST(TargetTest, Volume)
     SoundPrivate::audioOutput = nullptr;
 }
 
+TEST(TargetTest, SoundEffects)
+{
+    Target target;
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 0);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 0);
+
+    auto s1 = std::make_shared<SoundMock>();
+    auto s2 = std::make_shared<SoundMock>();
+    auto s3 = std::make_shared<SoundMock>();
+
+    EXPECT_CALL(*s1, setVolume);
+    EXPECT_CALL(*s2, setVolume);
+    EXPECT_CALL(*s3, setVolume);
+    target.addSound(s1);
+    target.addSound(s2);
+    target.addSound(s3);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pitch, 12.5));
+    EXPECT_CALL(*s2, setEffect(Sound::Effect::Pitch, 12.5));
+    EXPECT_CALL(*s3, setEffect(Sound::Effect::Pitch, 12.5));
+    target.setSoundEffectValue(Sound::Effect::Pitch, 12.5);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 12.5);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 0);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, -56.7));
+    EXPECT_CALL(*s2, setEffect(Sound::Effect::Pan, -56.7));
+    EXPECT_CALL(*s3, setEffect(Sound::Effect::Pan, -56.7));
+    target.setSoundEffectValue(Sound::Effect::Pan, -56.7);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 12.5);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), -56.7);
+
+    auto s4 = std::make_shared<SoundMock>();
+    EXPECT_CALL(*s4, setVolume);
+    EXPECT_CALL(*s4, setEffect(Sound::Effect::Pitch, 12.5));
+    EXPECT_CALL(*s4, setEffect(Sound::Effect::Pan, -56.7));
+    target.addSound(s4);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, 0));
+    EXPECT_CALL(*s2, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s2, setEffect(Sound::Effect::Pan, 0));
+    EXPECT_CALL(*s3, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s3, setEffect(Sound::Effect::Pan, 0));
+    EXPECT_CALL(*s4, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s4, setEffect(Sound::Effect::Pan, 0));
+    target.clearSoundEffects();
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 0);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 0);
+}
+
+TEST(TargetTest, CurrentCostumeWidth)
+{
+    Target target;
+    ASSERT_EQ(target.currentCostumeWidth(), 0);
+}
+
+TEST(TargetTest, CurrentCostumeHeight)
+{
+    Target target;
+    ASSERT_EQ(target.currentCostumeHeight(), 0);
+}
+
 TEST(TargetTest, BoundingRect)
 {
     Target target;
diff --git a/test/scratch_classes/value_test.cpp b/test/scratch_classes/value_test.cpp
index 97ab5a36..69ea1fa0 100644
--- a/test/scratch_classes/value_test.cpp
+++ b/test/scratch_classes/value_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/value.h>
+#include <utf8.h>
 
 #include "../common.h"
 
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 9f687d53..7faf3c49 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -42,24 +42,26 @@ TEST_F(ScriptTest, Bytecode)
     ASSERT_EQ(script.bytecodeVector(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
 }
 
-static Target *stageTest = nullptr;
+static Target *targetTest = nullptr;
 static IEngine *engineTest = nullptr;
 static Script *scriptTest = nullptr;
+static Value **variablesTest = nullptr;
+static List **listsTest = nullptr;
 
 TEST_F(ScriptTest, HatPredicate)
 {
     Script script(&m_target, nullptr, &m_engine);
-    ASSERT_FALSE(script.runHatPredicate());
-
-    Stage stage;
-    EXPECT_CALL(m_engine, stage()).Times(3).WillRepeatedly(Return(&stage));
+    Target target;
+    ASSERT_FALSE(script.runHatPredicate(&target));
 
     BlockFunc f1 = [](VirtualMachine *vm) -> unsigned int {
         vm->addReturnValue(true);
         vm->stop(false, false, false);
-        stageTest = vm->target();
+        targetTest = vm->target();
         engineTest = vm->engine();
         scriptTest = vm->script();
+        variablesTest = vm->variables();
+        listsTest = vm->lists();
         return 0;
     };
 
@@ -68,48 +70,70 @@ TEST_F(ScriptTest, HatPredicate)
     BlockFunc f3 = [](VirtualMachine *vm) -> unsigned int {
         vm->addReturnValue(false);
         vm->stop(false, false, false);
-        stageTest = vm->target();
+        targetTest = vm->target();
         engineTest = vm->engine();
         scriptTest = vm->script();
+        variablesTest = vm->variables();
+        listsTest = vm->lists();
         return 0;
     };
 
     std::vector<BlockFunc> functions1 = { f1 };
     std::vector<BlockFunc> functions2 = { f1, f2, f3 };
 
+    Variable var1("", "var1", "a");
+    Variable var2("", "var2", 4);
+    script.setVariables({ &var1, &var2 });
+
+    List list1("", "list1");
+    List list2("", "list2");
+    script.setLists({ &list1, &list2 });
+
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions1));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
+    variablesTest = nullptr;
+    listsTest = nullptr;
     script.setConstValues({ "test" });
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 0, vm::OP_HALT });
     testing::internal::CaptureStdout();
-    ASSERT_TRUE(script.runHatPredicate());
+    ASSERT_TRUE(script.runHatPredicate(&target));
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "test\n");
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_EQ(targetTest, &target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
+    ASSERT_TRUE(variablesTest);
+    ASSERT_EQ(variablesTest[0], var1.valuePtr());
+    ASSERT_EQ(variablesTest[1], var2.valuePtr());
+    ASSERT_TRUE(listsTest);
+    ASSERT_EQ(listsTest[0], &list1);
+    ASSERT_EQ(listsTest[1], &list2);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
+    variablesTest = nullptr;
+    listsTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 1, vm::OP_HALT });
     script.setConstValues({ 5 });
     testing::internal::CaptureStdout();
-    ASSERT_TRUE(script.runHatPredicate());
+    ASSERT_TRUE(script.runHatPredicate(&m_target));
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "5\n");
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_EQ(targetTest, &m_target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
-    stageTest = nullptr;
+    targetTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
+    variablesTest = nullptr;
+    listsTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_EXEC, 2, vm::OP_HALT });
-    ASSERT_FALSE(script.runHatPredicate());
-    ASSERT_EQ(stageTest, &stage);
+    ASSERT_FALSE(script.runHatPredicate(&target));
+    ASSERT_EQ(targetTest, &target);
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 }
diff --git a/test/target_interfaces/ispritehandler_test.cpp b/test/target_interfaces/ispritehandler_test.cpp
index f80772f1..752593e9 100644
--- a/test/target_interfaces/ispritehandler_test.cpp
+++ b/test/target_interfaces/ispritehandler_test.cpp
@@ -116,9 +116,21 @@ TEST_F(ISpriteHandlerTest, Position)
 
 TEST_F(ISpriteHandlerTest, Size)
 {
-    EXPECT_CALL(m_handler, onSizeChanged(53.8)).Times(1);
+    EXPECT_CALL(m_handler, onSizeChanged(53.8));
+    EXPECT_CALL(m_handler, costumeWidth()).WillOnce(Return(100));
+    EXPECT_CALL(m_handler, costumeHeight()).WillOnce(Return(100));
+    EXPECT_CALL(m_engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(m_engine, stageHeight()).WillOnce(Return(360));
     EXPECT_CALL(m_engine, requestRedraw());
     m_sprite.setSize(53.8);
+
+    EXPECT_CALL(m_handler, onSizeChanged(540));
+    EXPECT_CALL(m_handler, costumeWidth()).WillOnce(Return(100));
+    EXPECT_CALL(m_handler, costumeHeight()).WillOnce(Return(100));
+    EXPECT_CALL(m_engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(m_engine, stageHeight()).WillOnce(Return(360));
+    EXPECT_CALL(m_engine, requestRedraw());
+    m_sprite.setSize(100000);
 }
 
 TEST_F(ISpriteHandlerTest, Direction)
diff --git a/test/unsupported_blocks.sb3 b/test/unsupported_blocks.sb3
new file mode 100644
index 00000000..7098a654
Binary files /dev/null and b/test/unsupported_blocks.sb3 differ
diff --git a/test/virtual_machine/virtual_machine_test.cpp b/test/virtual_machine/virtual_machine_test.cpp
index 30ea6dbb..3a91c12c 100644
--- a/test/virtual_machine/virtual_machine_test.cpp
+++ b/test/virtual_machine/virtual_machine_test.cpp
@@ -1359,25 +1359,28 @@ TEST(VirtualMachineTest, OP_STR_LENGTH)
 TEST(VirtualMachineTest, OP_STR_CONTAINS)
 {
     static unsigned int bytecode[] = {
-        OP_START,        OP_CONST, 0, OP_CONST, 1, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 2, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 3,
-        OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 4, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 5, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 6,
-        OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 7, OP_STR_CONTAINS, OP_CONST, 4, OP_CONST, 4, OP_STR_CONTAINS, OP_HALT
+        OP_START,        OP_CONST, 0, OP_CONST, 1, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 2, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 3,  OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 4,
+        OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 5, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 6, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 7,  OP_STR_CONTAINS, OP_CONST, 4, OP_CONST, 4,
+        OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 8, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 9, OP_STR_CONTAINS, OP_CONST, 0, OP_CONST, 10, OP_STR_CONTAINS, OP_HALT
     };
-    static Value constValues[] = { "abcd efg  hijý abcĎĐ", "ĎĐ", "a", "test", "", " ", "  ", "k" };
+    static Value constValues[] = { "abcd efg  hijý abcĎĐ", "ĎĐ", "a", "test", "", " ", "  ", "k", "ab", "aB", "AB" };
 
     VirtualMachine vm;
     vm.setBytecode(bytecode);
     vm.setConstValues(constValues);
     vm.run();
-    ASSERT_EQ(vm.registerCount(), 8);
-    ASSERT_EQ(vm.getInput(0, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(1, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(2, 8)->toBool(), false);
-    ASSERT_EQ(vm.getInput(3, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(4, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(5, 8)->toBool(), true);
-    ASSERT_EQ(vm.getInput(6, 8)->toBool(), false);
-    ASSERT_EQ(vm.getInput(7, 8)->toBool(), true);
+    ASSERT_EQ(vm.registerCount(), 11);
+    ASSERT_EQ(vm.getInput(0, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(1, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(2, 11)->toBool(), false);
+    ASSERT_EQ(vm.getInput(3, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(4, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(5, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(6, 11)->toBool(), false);
+    ASSERT_EQ(vm.getInput(7, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(8, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(9, 11)->toBool(), true);
+    ASSERT_EQ(vm.getInput(10, 11)->toBool(), true);
 }
 
 unsigned int testFunction1(VirtualMachine *vm)
diff --git a/test/zip/zip_test.cpp b/test/zip/zip_test.cpp
index 666cfae7..a2a50576 100644
--- a/test/zip/zip_test.cpp
+++ b/test/zip/zip_test.cpp
@@ -8,7 +8,9 @@ inline std::string readSb3Json(const std::string &fileName)
     ZipReader reader(fileName);
     reader.open();
 
-    return reader.readFileToString("project.json");
+    std::string ret;
+    reader.readFileToString("project.json", ret);
+    return ret;
 }
 
 TEST(ZipTest, NonexistentProject)