diff --git a/CMakeLists.txt b/CMakeLists.txt
index 66a900c7..20c14a01 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.14)
 
-project(libscratchcpp VERSION 0.10.0 LANGUAGES C CXX)
+project(libscratchcpp VERSION 0.11.0 LANGUAGES C CXX)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_CXX_STANDARD 17)
@@ -31,11 +31,12 @@ target_sources(scratchcpp
     include/scratchcpp/scratchconfiguration.h
     include/scratchcpp/iengine.h
     include/scratchcpp/iextension.h
-    include/scratchcpp/iblocksection.h
+    include/scratchcpp/thread.h
     include/scratchcpp/asset.h
     include/scratchcpp/costume.h
     include/scratchcpp/sound.h
     include/scratchcpp/value.h
+    include/scratchcpp/valuedata.h
     include/scratchcpp/entity.h
     include/scratchcpp/variable.h
     include/scratchcpp/list.h
@@ -50,9 +51,11 @@ target_sources(scratchcpp
     include/scratchcpp/block.h
     include/scratchcpp/istagehandler.h
     include/scratchcpp/ispritehandler.h
+    include/scratchcpp/drawable.h
     include/scratchcpp/target.h
     include/scratchcpp/stage.h
     include/scratchcpp/sprite.h
+    include/scratchcpp/textbubble.h
     include/scratchcpp/itimer.h
     include/scratchcpp/keyevent.h
     include/scratchcpp/rect.h
diff --git a/Doxyfile b/Doxyfile
index 9b266624..c2fcdb0a 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -958,7 +958,9 @@ RECURSIVE              = YES
 # run.
 
 EXCLUDE                = docs/theme \
-                         include/scratchcpp/spimpl.h
+                         include/scratchcpp/spimpl.h \
+                         include/scratchcpp/signal.h \
+                         include/scratchcpp/veque.h
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
diff --git a/docs/Block sections.md b/docs/Block sections.md
deleted file mode 100644
index a3d75212..00000000
--- a/docs/Block sections.md	
+++ /dev/null
@@ -1,158 +0,0 @@
-\page blockSections Block sections
-
-A block section is a group of Scratch blocks, for example motion blocks.
-
-Block sections are created using the \link libscratchcpp::IBlockSection IBlockSection \endlink interface.
-
-## Creating a block section
-To create a custom block section, subclass \link libscratchcpp::IBlockSection IBlockSection \endlink and override
-\link libscratchcpp::IBlockSection::name() name() \endlink to return the block section name.
-
-It's recommended to use the libscratchcpp namespace like this in your block section class:
-```cpp
-using namespace libscratchcpp;
-```
-
-### Adding blocks
-See the [Scratch Wiki](https://en.scratch-wiki.info/wiki/Scratch_File_Format#Blocks) for more information about blocks.
-
-Scratch projects are compiled by the \link libscratchcpp::Compiler Compiler \endlink class.
-To add a block, you have to let the compiler know how to compile it.
-Start by defining a **compile function**.
-For example, the compile function for a `hello world` block would look like this:
-```cpp
-class MySection : public IBlockSection {
-    public:
-        ...
-        static void compileHelloWorld(Compiler *compiler);
-        static unsigned int helloWorld(VirtualMachine *vm);
-};
-
-void MySection::compileHelloWorld(Compiler *compiler) {
-    compiler->addFunctionCall(&helloWorld);
-}
-
-unsigned int MySection::helloWorld(VirtualMachine *vm) {
-    std::cout << "Hello, world!" << std::endl;
-    return 0;
-}
-```
-\note Make sure the functions are **static**.
-
-Register the compile function using the \link libscratchcpp::IBlockSection::addCompileFunction() addCompileFunction() \endlink method in the constructor:
-```cpp
-MySection::MySection() {
-    addCompileFunction("mysection_helloworld", &MySection::compileHelloWorld);
-}
-```
-Where `mysection_helloworld` is the opcode of the `hello world` block.
-
-### Adding inputs
-To add inputs, create an `Inputs` enumeration in your block section:
-```hpp
-class MySection : public IBlockSection {
-    enum Inputs {
-        TEXT
-    };
-    ...
-};
-```
-Then add inputs in the constructor:
-```cpp
-MySection::MySection() {
-    ...
-    addInput("TEXT", TEXT);
-}
-```
-The compiler will assign the input name with the `TEXT` ID. In this case, the ID is 0 because it's the first member of the enumeration.
-
-To add the input to the compiled code, call the \link libscratchcpp::Compiler::addInput() addInput() \endlink function:
-```cpp
-void MySection::compileHelloWorld(Compiler *compiler) {
-    compiler->addInput(TEXT);
-    compiler->addFunctionCall(&helloWorld);
-}
-```
-
-The value of the input can be read during runtime using the \link libscratchcpp::VirtualMachine::getInput() getInput() \endlink function:
-```cpp
-unsigned int MySection::helloWorld(VirtualMachine *vm) {
-    std::cout << "Hello, " << vm->getInput(0, 1)->toString() << "!" << std::endl;
-    return 1;
-}
-```
-\note The order of the inputs is the same as in the compile function. Do not use the `Inputs` enumeration in runtime functions.
-
-```cpp
-vm->getInput(0, 1)
-```
-The first argument is the index of the input and the second argument is the amount of inputs.
-\note Make sure to return the amount of inputs in the `helloWorld` function.
-
-### Adding fields
-**Fields** are drop-down menus into which one cannot drop a reporter.
-Fields have a predefined set of values.
-```cpp
-class MySection : public IBlockSection {
-    ...
-    enum Fields {
-        ANIMAL
-    };
-
-    enum FieldValues {
-        Cat,
-        Dog
-    };
-    ...
-};
-
-MySection::MySection() {
-    ...
-    addField("ANIMAL", ANIMAL);
-}
-```
-
-Because fields are handled at compile time, you can read them from the compile function:
-```cpp
-void MySection::compileHelloWorld(Compiler *compiler) {
-    int id = compiler->field(ANIMAL)->specialValueId();
-
-    switch(id) {
-        case Cat:
-            compiler->addFunctionCall(&helloCat);
-            break;
-
-        case Dog:
-            compiler->addFunctionCall(&helloDog);
-            break;
-
-        default:
-            break;
-    }
-}
-
-unsigned int MySection::helloCat(VirtualMachine *vm) {
-    std::cout << "Hello, cat!" << std::endl;
-    return 0;
-}
-
-unsigned int MySection::helloDog(VirtualMachine *vm) {
-    std::cout << "Hello, dog!" << std::endl;
-    return 0;
-}
-```
-\note Don't confuse \link libscratchcpp::Field::specialValueId() specialValueId() \endlink with \link libscratchcpp::Field::valueId() valueId() \endlink
-because \link libscratchcpp::Field::valueId() valueId() \endlink stores the ID of the block, variable, list or broadcast selected in the dropdown list.
-
-To get a pointer to the block, variable, list or broadcast selected in the dropdown list, use \link libscratchcpp::Field::valuePtr() valuePtr() \endlink.
-
-### Registering the block section
-Block sections are registered in the \link libscratchcpp::IExtension::registerSections() registerSections() \endlink
-function of an extension:
-
-```cpp
-void MyExtension::registerSections(Engine *engine) {
-    engine->registerSection(std::make_shared<MySection>());
-}
-```
-See the [Extensions](extensions.html) page for instructions on how to create an extension.
diff --git a/docs/Extensions.md b/docs/Extensions.md
index 2e076d08..5e0d3836 100644
--- a/docs/Extensions.md
+++ b/docs/Extensions.md
@@ -1,30 +1,152 @@
 \page extensions Extensions
 
-An extension is a group of block sections (see [Block sections](blockSections.html)).
+An extension is a group of Scratch blocks, for example motion blocks.
 
 ## Creating an extension
 To create a custom extension, subclass \link libscratchcpp::IExtension IExtension \endlink and override
 \link libscratchcpp::IExtension::name() name() \endlink and \link libscratchcpp::IExtension::description() description() \endlink
-functions to return the name and the description of the extension.
-
-There's also an \link libscratchcpp::IExtension::includeByDefault() includeByDefault() \endlink function which returns `true`
-if the extension is intended to be hidden from the block palette and included in a Scratch project by default.
-
-The default implementation returns `false`.
+functions to return the name and the description of the extension. Then override \link libscratchcpp::IExtension::registerBlocks() registerBlocks() \endlink
+where you'll register the compile functions for blocks.
 
 It's recommended to use the libscratchcpp namespace like this in your extension class:
 ```cpp
 using namespace libscratchcpp;
 ```
 
-### Registering block sections
-Block sections can be registered by overriding the \link libscratchcpp::IExtension::registerSections() registerSections() \endlink function:
+### Adding blocks
+See the [Scratch Wiki](https://en.scratch-wiki.info/wiki/Scratch_File_Format#Blocks) for more information about blocks.
+
+Scratch projects are compiled by the \link libscratchcpp::Compiler Compiler \endlink class.
+To add a block, you have to let the compiler know how to compile it.
+Start by defining a **compile function**.
+For example, the compile function for a `hello world` block would look like this:
+```cpp
+class MyExtension : public IExtension {
+    public:
+        ...
+        static void compileHelloWorld(Compiler *compiler);
+        static unsigned int helloWorld(VirtualMachine *vm);
+};
+
+void MyExtension::compileHelloWorld(Compiler *compiler) {
+    compiler->addFunctionCall(&helloWorld);
+}
+
+unsigned int MyExtension::helloWorld(VirtualMachine *vm) {
+    std::cout << "Hello, world!" << std::endl;
+    return 0;
+}
+```
+\note Make sure the functions are **static**.
+
+Register the compile function using the \link libscratchcpp::IEngine::addCompileFunction() addCompileFunction() \endlink method in link libscratchcpp::IExtension::registerBlocks() registerBlocks() \endlink:
+```cpp
+MyExtension::registerBlocks(IEngine *engine) {
+    engine->addCompileFunction(this, "myextension_helloworld", &MyExtension::compileHelloWorld);
+}
+```
+Where `myextension_helloworld` is the opcode of the `hello world` block.
+
+### Adding inputs
+To add inputs, create an `Inputs` enumeration in your extension:
+```hpp
+class MyExtension : public IExtension {
+    enum Inputs {
+        TEXT
+    };
+    ...
+};
+```
+Then add inputs in link libscratchcpp::IExtension::registerBlocks() registerBlocks() \endlink:
+```cpp
+MyExtension::registerBlocks(IEngine *engine) {
+    ...
+    engine->addInput(this, "TEXT", TEXT);
+}
+```
+The compiler will assign the input name with the `TEXT` ID. In this case, the ID is 0 because it's the first member of the enumeration.
+
+To add the input to the compiled code, call the \link libscratchcpp::Compiler::addInput() addInput() \endlink function:
+```cpp
+void MyExtension::compileHelloWorld(Compiler *compiler) {
+    compiler->addInput(TEXT);
+    compiler->addFunctionCall(&helloWorld);
+}
+```
+
+The value of the input can be read during runtime using the \link libscratchcpp::VirtualMachine::getInput() getInput() \endlink function:
+```cpp
+unsigned int MyExtension::helloWorld(VirtualMachine *vm) {
+    std::cout << "Hello, " << vm->getInput(0, 1)->toString() << "!" << std::endl;
+    return 1;
+}
+```
+\note The order of the inputs is the same as in the compile function. Do not use the `Inputs` enumeration in runtime functions.
+
+```cpp
+vm->getInput(0, 1)
+```
+The first argument is the index of the input and the second argument is the amount of inputs.
+\note Make sure to return the amount of inputs in the `helloWorld` function.
+
+### Adding fields
+**Fields** are drop-down menus into which one cannot drop a reporter.
+Fields have a predefined set of values.
+```cpp
+class MyExtension : public IExtension {
+    ...
+    enum Fields {
+        ANIMAL
+    };
+
+    enum FieldValues {
+        Cat,
+        Dog
+    };
+    ...
+};
+
+MyExtension::registerBlocks(IEngine *engine) {
+    ...
+    engine->addField(this, "ANIMAL", ANIMAL);
+    engine->addFieldValue(this, "Cat", Cat);
+    engine->addFieldValue(this, "Dog", Dog);
+}
+```
+
+Because fields are handled at compile time, you can read them from the compile function:
 ```cpp
-void MyExtension::registerSections(IEngine *engine) {
-    engine->registerSection(std::make_shared<MySection>());
+void MyExtension::compileHelloWorld(Compiler *compiler) {
+    int id = compiler->field(ANIMAL)->specialValueId();
+
+    switch(id) {
+        case Cat:
+            compiler->addFunctionCall(&helloCat);
+            break;
+
+        case Dog:
+            compiler->addFunctionCall(&helloDog);
+            break;
+
+        default:
+            break;
+    }
+}
+
+unsigned int MyExtension::helloCat(VirtualMachine *vm) {
+    std::cout << "Hello, cat!" << std::endl;
+    return 0;
+}
+
+unsigned int MyExtension::helloDog(VirtualMachine *vm) {
+    std::cout << "Hello, dog!" << std::endl;
+    return 0;
 }
 ```
-See the [Block sections](blockSections.html) page for instructions on how to create a block section.
+\note Don't confuse \link libscratchcpp::Field::specialValueId() specialValueId() \endlink with \link libscratchcpp::Field::valueId() valueId() \endlink
+because \link libscratchcpp::Field::valueId() valueId() \endlink stores the ID of the block, variable, list or broadcast selected in the dropdown list.
+
+To get a pointer to the block, variable, list or broadcast selected in the dropdown list, use \link libscratchcpp::Field::valuePtr() valuePtr() \endlink.
 
 ### Registering the extension
 Register the extension **before** loading a project, using the \link libscratchcpp::ScratchConfiguration ScratchConfiguration \endlink class:
diff --git a/docs/Getting started.md b/docs/Getting started.md
index 859fd4f0..b9b5dfaf 100644
--- a/docs/Getting started.md	
+++ b/docs/Getting started.md	
@@ -24,5 +24,5 @@ int main(int argc, char **argv) {
 The \link libscratchcpp::Project::run() run() \endlink method runs an event loop which stops after all scripts finish.
 
 For CLI project players, using \link libscratchcpp::Project::run() run() \endlink is enough. If you are developing
-a GUI project player and need to receive input events such as key presses, you'll need to use \link libscratchcpp::Project::runEventLoop() runEventLoop() \endlink
-and run it in another thread (to keep the UI responsive).
+a GUI project player and need to receive input events such as key presses, you'll need to use \link libscratchcpp::IEngine::step() step() \endlink
+for ticks and \link libscratchcpp::Project::start() start() \endlink and \link libscratchcpp::Project::stop() stop() \endlink
diff --git a/docs/Image formats.md b/docs/Image formats.md
deleted file mode 100644
index f1173bd1..00000000
--- a/docs/Image formats.md	
+++ /dev/null
@@ -1,33 +0,0 @@
-\page imageFormats Image formats
-
-To work with costumes, libscratchcpp has to read image files from Scratch projects.
-Only JPEG and PNG are currently supported, but SVG is going to be supported in the future.
-
-# Implementing a custom image format
-To implement a custom image format that libscratchcpp doesn't support,
-subclass \link libscratchcpp::IImageFormat IImageFormat \endlink
-and override all of the methods.
-
-Then subclass \link libscratchcpp::IImageFormatFactory IImageFormatFactory \endlink
-and override \link libscratchcpp::IImageFormatFactory::createInstance() createInstance() \endlink.
-
-It's recommended to use the libscratchcpp namespace like this in your classes:
-```cpp
-using namespace libscratchcpp;
-```
-
-Here's an example of the `createInstance()` method:
-```cpp
-std::shared_ptr<IImageFormat> TiffImageFormatFactory::createInstance() {
-    return std::make_shared<TiffImageFormat>();
-}
-```
-
-# Registering the image format
-To register the image format, you need to register the factory class.
-It will be used by classes such as \link libscratchcpp::Costume Costume \endlink
-internally to instantiate your image format.
-
-```cpp
-libscratchcpp::ScratchConfiguration::registerImageFormat("tiff", std::make_shared<TiffImageFormatFactory>());
-```
diff --git a/include/scratchcpp/drawable.h b/include/scratchcpp/drawable.h
new file mode 100644
index 00000000..8424bf59
--- /dev/null
+++ b/include/scratchcpp/drawable.h
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "global.h"
+#include "spimpl.h"
+
+namespace libscratchcpp
+{
+
+class IEngine;
+
+class DrawablePrivate;
+
+/*! \brief The Drawable class is the base class of rendered elements (stage, sprites, text bubbles). */
+class LIBSCRATCHCPP_EXPORT Drawable
+{
+    public:
+        Drawable();
+        Drawable(const Drawable &) = delete;
+
+        /*! Returns true if this Drawable is a Target. */
+        virtual bool isTarget() const { return false; }
+
+        /*! Returns true if this Drawable is a TextBubble. */
+        virtual bool isTextBubble() const { return false; }
+
+        int layerOrder() const;
+        virtual void setLayerOrder(int newLayerOrder);
+
+        IEngine *engine() const;
+        virtual void setEngine(IEngine *engine);
+
+    private:
+        spimpl::unique_impl_ptr<DrawablePrivate> impl;
+};
+
+} // namespace libscratchcpp
diff --git a/include/scratchcpp/iblocksection.h b/include/scratchcpp/iblocksection.h
deleted file mode 100644
index 92b71cfb..00000000
--- a/include/scratchcpp/iblocksection.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-#pragma once
-
-#include <string>
-#include <map>
-#include "spimpl.h"
-
-#include "global.h"
-
-namespace libscratchcpp
-{
-
-class BlockSectionPrivate;
-class IEngine;
-
-/*!
- * \brief The IBlockSection class is an interface for block sections/categories.
- *
- * \see <a href="blockSections.html">Block sections</a>
- */
-class LIBSCRATCHCPP_EXPORT IBlockSection
-{
-    public:
-        virtual ~IBlockSection() { }
-
-        /*! Override this method to return the name of the block section. */
-        virtual std::string name() const = 0;
-
-        /*!
-         * Override this method to configure whether the category in the block palette should be visible.\n
-         * For example, there isn't a list category in the Scratch user interface.
-         * \note The default implementation returns true.
-         */
-        virtual bool categoryVisible() const { return true; }
-
-        /*! Override this method to register blocks. */
-        virtual void registerBlocks(IEngine *engine) = 0;
-
-        /*! This method is called when a project is loaded. */
-        virtual void onInit(IEngine *engine) { }
-};
-
-} // namespace libscratchcpp
diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index aa5aac94..a8cffbc2 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -14,15 +14,18 @@
 namespace libscratchcpp
 {
 
-class IBlockSection;
+class IExtension;
 class Broadcast;
 class Block;
+class Field;
+class Drawable;
 class Target;
 class Sprite;
 class Stage;
 class Variable;
 class List;
 class Script;
+class Thread;
 class ITimer;
 class KeyEvent;
 class Monitor;
@@ -58,26 +61,26 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void stop() = 0;
 
         /*! Starts a script with the given top level block as the given Target (a sprite or the stage). */
-        virtual VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *) = 0;
+        virtual Thread *startScript(std::shared_ptr<Block> topLevelBlock, Target *) = 0;
 
         /*! Starts the scripts of the broadcast with the given index. */
-        virtual void broadcast(int index) = 0;
+        virtual void broadcast(int index, Thread *sender, bool wait) = 0;
 
         /*! Starts the scripts of the given broadcast. */
-        virtual void broadcastByPtr(Broadcast *broadcast) = 0;
+        virtual void broadcastByPtr(Broadcast *broadcast, Thread *sender, bool wait) = 0;
 
         /*! Starts the "when backdrop switches to" scripts for the given backdrop broadcast. */
-        virtual void startBackdropScripts(Broadcast *broadcast) = 0;
+        virtual void startBackdropScripts(Broadcast *broadcast, Thread *sender, bool wait) = 0;
 
         /*! Stops the given script. */
-        virtual void stopScript(VirtualMachine *vm) = 0;
+        virtual void stopScript(Thread *vm) = 0;
 
         /*!
          * Stops all scripts in the given target.
          * \param[in] target The Target to stop.
          * \param[in] exceptScript Sets this parameter to stop all scripts except the given script.
          */
-        virtual void stopTarget(Target *target, VirtualMachine *exceptScript) = 0;
+        virtual void stopTarget(Target *target, Thread *exceptScript) = 0;
 
         /*! Calls the "when I start as a clone" blocks of the given sprite. */
         virtual void initClone(std::shared_ptr<Sprite> clone) = 0;
@@ -121,7 +124,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual sigslot::signal<> &aboutToRender() = 0;
 
         /*! Emits when a script is about to stop. */
-        virtual sigslot::signal<VirtualMachine *> &threadAboutToStop() = 0;
+        virtual sigslot::signal<Thread *> &threadAboutToStop() = 0;
 
         /*! Emits when the project is stopped by calling stop(). */
         virtual sigslot::signal<> &stopped() = 0;
@@ -207,12 +210,6 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Toggles sprite fencing. */
         virtual void setSpriteFencingEnabled(bool enable) = 0;
 
-        /*! Returns true if there are any running script of the broadcast with the given index. */
-        virtual bool broadcastRunning(unsigned int index) = 0;
-
-        /*! Returns true if there are any running script of the given broadcast. */
-        virtual bool broadcastByPtrRunning(Broadcast *broadcast) = 0;
-
         /*!
          * Call this from a block implementation to force a redraw (screen refresh).
          * \note This has no effect in "run without screen refresh" custom blocks.
@@ -222,12 +219,6 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the timer of the project. */
         virtual ITimer *timer() const = 0;
 
-        /*!
-         * Registers the given block section.
-         * \see <a href="blockSections.html">Block sections</a>
-         */
-        virtual void registerSection(std::shared_ptr<IBlockSection> section) = 0;
-
         /*! Returns the index of the given block function. */
         virtual unsigned int functionIndex(BlockFunc f) = 0;
 
@@ -235,53 +226,53 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual const std::vector<BlockFunc> &blockFunctions() const = 0;
 
         /*!
-         * Call this from IBlockSection#registerBlocks() to add a compile function to a block section.
-         * \see <a href="blockSections.html">Block sections</a>
+         * Call this from IExtension#registerBlocks() to add a compile function to a block section.
+         * \see <a href="extensions.html">Extensions</a>
          */
-        virtual void addCompileFunction(IBlockSection *section, const std::string &opcode, BlockComp f) = 0;
+        virtual void addCompileFunction(IExtension *extension, const std::string &opcode, BlockComp f) = 0;
 
         /*!
-         * Call this from IBlockSection#registerBlocks() to add a hat block predicate compile function to a block section.
+         * Call this from IExtension#registerBlocks() to add a hat block predicate compile function to a block section.
          * \note This only works with edge-activated hats.
-         * \see <a href="blockSections.html">Block sections</a>
+         * \see <a href="extensions.html">Extensions</a>
          */
-        virtual void addHatPredicateCompileFunction(IBlockSection *section, const std::string &opcode, HatPredicateCompileFunc f) = 0;
+        virtual void addHatPredicateCompileFunction(IExtension *extension, const std::string &opcode, HatPredicateCompileFunc f) = 0;
 
         /*!
-         * Call this from IBlockSection#registerBlocks() to add a monitor name function to a block section.
-         * \see <a href="blockSections.html">Block sections</a>
+         * Call this from IExtension#registerBlocks() to add a monitor name function to a block section.
+         * \see <a href="extensions.html">Extensions</a>
          */
-        virtual void addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f) = 0;
+        virtual void addMonitorNameFunction(IExtension *extension, const std::string &opcode, MonitorNameFunc f) = 0;
 
         /*!
-         * Call this from IBlockSection#registerBlocks() to add a monitor value change function to a block section.
-         * \see <a href="blockSections.html">Block sections</a>
+         * Call this from IExtension#registerBlocks() to add a monitor value change function to a block section.
+         * \see <a href="extensions.html">Extensions</a>
          */
-        virtual void addMonitorChangeFunction(IBlockSection *section, const std::string &opcode, MonitorChangeFunc f) = 0;
+        virtual void addMonitorChangeFunction(IExtension *extension, const std::string &opcode, MonitorChangeFunc f) = 0;
 
         /*!
-         * Call this from IBlockSection#registerBlocks() to add a hat block to a block section.
-         * \see <a href="blockSections.html">Block sections</a>
+         * Call this from IExtension#registerBlocks() to add a hat block to a block section.
+         * \see <a href="extensions.html">Extensions</a>
          */
-        virtual void addHatBlock(IBlockSection *section, const std::string &opcode) = 0;
+        virtual void addHatBlock(IExtension *extension, const std::string &opcode) = 0;
 
         /*!
-         * Call this from IBlockSection#registerBlocks() to add an input to a block section.
-         * \see <a href="blockSections.html">Block sections</a>
+         * Call this from IExtension#registerBlocks() to add an input to a block section.
+         * \see <a href="extensions.html">Extensions</a>
          */
-        virtual void addInput(IBlockSection *section, const std::string &name, int id) = 0;
+        virtual void addInput(IExtension *extension, const std::string &name, int id) = 0;
 
         /*!
-         * Call this from IBlockSection#registerBlocks() to add a field to a block section.
-         * \see <a href="blockSections.html">Block sections</a>
+         * Call this from IExtension#registerBlocks() to add a field to a block section.
+         * \see <a href="extensions.html">Extensions</a>
          */
-        virtual void addField(IBlockSection *section, const std::string &name, int id) = 0;
+        virtual void addField(IExtension *extension, const std::string &name, int id) = 0;
 
         /*!
-         * Call this from IBlockSection#registerBlocks() to add a field value to a block section.
-         * \see <a href="blockSections.html">Block sections</a>
+         * Call this from IExtension#registerBlocks() to add a field value to a block section.
+         * \see <a href="extensions.html">Extensions</a>
          */
-        virtual void addFieldValue(IBlockSection *section, const std::string &value, int id) = 0;
+        virtual void addFieldValue(IExtension *extension, const std::string &value, int id) = 0;
 
         /*! Returns the list of broadcasts. */
         virtual const std::vector<std::shared_ptr<Broadcast>> &broadcasts() const = 0;
@@ -305,16 +296,16 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void addGreenFlagScript(std::shared_ptr<Block> hatBlock) = 0;
 
         /*! Registers the broadcast script. */
-        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast) = 0;
+        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Field *field, Broadcast *broadcast) = 0;
 
         /*! Registers the backdrop change script. */
-        virtual void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId) = 0;
+        virtual void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, Field *field) = 0;
 
         /* Registers the given "when I start as clone" script. */
         virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
 
         /* Registers the given "when key pressed" script. */
-        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId) = 0;
+        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock, Field *field) = 0;
 
         /* Registers the given "when this sprite/stage clicked" script. */
         virtual void addTargetClickScript(std::shared_ptr<Block> hatBlock) = 0;
@@ -331,6 +322,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the target at index. */
         virtual Target *targetAt(int index) const = 0;
 
+        /*! Gets visible targets sorted by layer order and stores them in the given vector. */
+        virtual void getVisibleTargets(std::vector<Target *> &dst) const = 0;
+
         /*!
          * Returns the index of the target with the given name.
          * \note Using "Stage" will return the index of the sprite with this name, or nullptr if it doesn't exist.
@@ -339,19 +333,19 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual int findTarget(const std::string &targetName) const = 0;
 
         /*! Moves the given sprite to the front layer. */
-        virtual void moveSpriteToFront(Sprite *sprite) = 0;
+        virtual void moveDrawableToFront(Drawable *drawable) = 0;
 
         /*! Moves the given sprite to the back layer. */
-        virtual void moveSpriteToBack(Sprite *sprite) = 0;
+        virtual void moveDrawableToBack(Drawable *drawable) = 0;
 
         /*! Moves the given sprite forward a number of layers. */
-        virtual void moveSpriteForwardLayers(Sprite *sprite, int layers) = 0;
+        virtual void moveDrawableForwardLayers(Drawable *drawable, int layers) = 0;
 
         /*! Moves the given sprite backward a number of layers. */
-        virtual void moveSpriteBackwardLayers(Sprite *sprite, int layers) = 0;
+        virtual void moveDrawableBackwardLayers(Drawable *drawable, int layers) = 0;
 
         /*! Moves the given sprite behind some other sprite. */
-        virtual void moveSpriteBehindOther(Sprite *sprite, Sprite *other) = 0;
+        virtual void moveDrawableBehindOther(Drawable *drawable, Drawable *other) = 0;
 
         /*! Returns the Stage. */
         virtual Stage *stage() const = 0;
@@ -362,6 +356,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Sets the list of monitors. */
         virtual void setMonitors(const std::vector<std::shared_ptr<Monitor>> &newMonitors) = 0;
 
+        /*! Creates a monitor for the given variable if it's missing and returns it. */
+        virtual Monitor *createVariableMonitor(std::shared_ptr<Variable> var, const std::string &opcode, const std::string &varFieldName, int varFieldId, BlockComp compileFunction) = 0;
+
+        /*! Creates a monitor for the given list if it's missing and returns it. */
+        virtual Monitor *createListMonitor(std::shared_ptr<List> list, const std::string &opcode, const std::string &listFieldName, int listFieldId, BlockComp compileFunction) = 0;
+
         /*! Emits when a monitor is added. */
         virtual sigslot::signal<Monitor *> &monitorAdded() = 0;
 
diff --git a/include/scratchcpp/iextension.h b/include/scratchcpp/iextension.h
index ccd65ec6..a53b8356 100644
--- a/include/scratchcpp/iextension.h
+++ b/include/scratchcpp/iextension.h
@@ -27,14 +27,11 @@ class LIBSCRATCHCPP_EXPORT IExtension
         /*! Returns the description of the extension. */
         virtual std::string description() const = 0;
 
-        /*!
-         * Returns true if the extension is hidden from the block palette
-         * and should be available in a Scratch project by default
-         */
-        virtual bool includeByDefault() const { return false; }
-
-        /*! Registers block sections. \see <a href="blockSections.html">Block sections</a> */
-        virtual void registerSections(IEngine *engine) = 0;
+        /*! Override this method to register blocks. */
+        virtual void registerBlocks(IEngine *engine) = 0;
+
+        /*! This method is called when a project is loaded. */
+        virtual void onInit(IEngine *engine) { }
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/igraphicseffect.h b/include/scratchcpp/igraphicseffect.h
index 7520cfc4..cc3a58eb 100644
--- a/include/scratchcpp/igraphicseffect.h
+++ b/include/scratchcpp/igraphicseffect.h
@@ -17,6 +17,9 @@ class LIBSCRATCHCPP_EXPORT IGraphicsEffect
 
         /*! Returns the name of the graphics effect. */
         virtual std::string name() const = 0;
+
+        /*! Returns the clamped value of the graphic effect. */
+        virtual double clamp(double value) const = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/imonitorhandler.h b/include/scratchcpp/imonitorhandler.h
index ac5180ce..d31582ba 100644
--- a/include/scratchcpp/imonitorhandler.h
+++ b/include/scratchcpp/imonitorhandler.h
@@ -18,6 +18,8 @@ class LIBSCRATCHCPP_EXPORT IMonitorHandler
         virtual void init(Monitor *monitor) = 0;
 
         virtual void onValueChanged(const VirtualMachine *vm) = 0;
+        virtual void onXChanged(int x) = 0;
+        virtual void onYChanged(int y) = 0;
         virtual void onVisibleChanged(bool visible) = 0;
 };
 
diff --git a/include/scratchcpp/ispritehandler.h b/include/scratchcpp/ispritehandler.h
index 9bfb4307..d8a61a68 100644
--- a/include/scratchcpp/ispritehandler.h
+++ b/include/scratchcpp/ispritehandler.h
@@ -59,12 +59,6 @@ class LIBSCRATCHCPP_EXPORT ISpriteHandler
         /*! Called when all graphics effects are cleared. */
         virtual void onGraphicsEffectsCleared() = 0;
 
-        /*! Called when the bubble type changes. */
-        virtual void onBubbleTypeChanged(Target::BubbleType type) = 0;
-
-        /*! 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;
 
@@ -92,6 +86,9 @@ class LIBSCRATCHCPP_EXPORT ISpriteHandler
 
         /*! Used to check whether the sprite touches the given color. */
         virtual bool touchingColor(const Value &color) const = 0;
+
+        /*! Used to check whether the mask part of the sprite touches the given color. */
+        virtual bool touchingColor(const Value &color, const Value &mask) const = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/istagehandler.h b/include/scratchcpp/istagehandler.h
index 0b397e17..b6cf7f50 100644
--- a/include/scratchcpp/istagehandler.h
+++ b/include/scratchcpp/istagehandler.h
@@ -40,12 +40,6 @@ class LIBSCRATCHCPP_EXPORT IStageHandler
         /*! Called when all graphics effects are cleared. */
         virtual void onGraphicsEffectsCleared() = 0;
 
-        /*! Called when the bubble type changes. */
-        virtual void onBubbleTypeChanged(Target::BubbleType type) = 0;
-
-        /*! 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;
 
@@ -69,6 +63,9 @@ class LIBSCRATCHCPP_EXPORT IStageHandler
 
         /*! Used to check whether the stage touches the given color. */
         virtual bool touchingColor(const Value &color) const = 0;
+
+        /*! Used to check whether the mask part of the stage touches the given color. */
+        virtual bool touchingColor(const Value &color, const Value &mask) const = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/list.h b/include/scratchcpp/list.h
index 6d63e8b2..8ce30c85 100644
--- a/include/scratchcpp/list.h
+++ b/include/scratchcpp/list.h
@@ -3,7 +3,7 @@
 #pragma once
 
 #include <string>
-#include <deque>
+#include <scratchcpp/veque.h>
 
 #include "value.h"
 #include "entity.h"
@@ -15,15 +15,19 @@ class Target;
 class Monitor;
 class ListPrivate;
 
-/*! \brief The List class represents a Scratch list. */
-class LIBSCRATCHCPP_EXPORT List
-    : public std::deque<Value>
-    , public Entity
+/*!
+ * \brief The List class represents a Scratch list.
+ *
+ * Due to the high optimization of the methods, indices out of range will result in undefined behavior!
+ */
+class LIBSCRATCHCPP_EXPORT List : public Entity
 {
     public:
         List(const std::string &id, const std::string &name);
         List(const List &) = delete;
 
+        ~List();
+
         const std::string &name();
         void setName(const std::string &name);
 
@@ -33,24 +37,197 @@ class LIBSCRATCHCPP_EXPORT List
         Monitor *monitor() const;
         void setMonitor(Monitor *monitor);
 
-        long indexOf(const Value &value) const;
-        bool contains(const Value &value) const;
+        /*! Returns the list size. */
+        inline size_t size() const { return m_size; }
+
+        /*! Returns true if the list is empty. */
+        inline bool empty() const { return m_size == 0; }
+
+        /*! Returns the index of the given item. */
+        inline size_t indexOf(const ValueData &value) const
+        {
+            for (size_t i = 0; i < m_size; i++) {
+                if (value_equals(&m_dataPtr->operator[](i), &value))
+                    return i;
+            }
+
+            return -1;
+        }
+
+        /*! Returns the index of the given item. */
+        inline size_t indexOf(const Value &value) const { return indexOf(value.data()); }
+
+        /*! Returns true if the list contains the given item. */
+        inline bool contains(const ValueData &value) const { return (indexOf(value) != -1); }
+
+        /*! Returns true if the list contains the given item. */
+        inline bool contains(const Value &value) const { return contains(value.data()); }
+
+        /*! Clears the list. */
+        inline void clear()
+        {
+            // Keep at least 200,000 items allocated if the list has more
+            constexpr size_t limit = 200000;
+            m_size = 0;
+
+            if (m_dataPtr->size() > limit)
+                reserve(limit);
+        }
+
+        /*! Appends an empty item and returns the reference to it. Can be used for custom initialization. */
+        inline ValueData &appendEmpty()
+        {
+            m_size++;
+            reserve(getAllocSize(m_size));
+            return m_dataPtr->operator[](m_size - 1);
+        }
+
+        /*! Appends an item. */
+        inline void append(const ValueData &value) { value_assign_copy(&appendEmpty(), &value); }
+
+        /*! Appends an item. */
+        inline void append(const Value &value) { append(value.data()); }
 
         /*! Removes the item at index. */
-        void removeAt(int index) { erase(begin() + index); }
+        inline void removeAt(size_t index)
+        {
+            assert(index >= 0 && index < size());
+            std::rotate(m_dataPtr->begin() + index, m_dataPtr->begin() + index + 1, m_dataPtr->begin() + m_size);
+            m_size--;
+        }
+
+        /*! Inserts an item at index. */
+        inline void insert(size_t index, const ValueData &value)
+        {
+            assert(index >= 0 && index <= size());
+            m_size++;
+            reserve(getAllocSize(m_size));
+            std::rotate(m_dataPtr->rbegin() + m_dataPtr->size() - m_size, m_dataPtr->rbegin() + m_dataPtr->size() - m_size + 1, m_dataPtr->rend() - index);
+            value_assign_copy(&m_dataPtr->operator[](index), &value);
+        }
 
         /*! Inserts an item at index. */
-        void insert(int index, const Value &value) { std::deque<Value>::insert(begin() + index, value); }
+        inline void insert(size_t index, const Value &value) { insert(index, value.data()); }
 
         /*! Replaces the item at index. */
-        void replace(int index, const Value &value) { at(index) = value; }
+        inline void replace(size_t index, const ValueData &value)
+        {
+            assert(index >= 0 && index < size());
+            value_assign_copy(&m_dataPtr->operator[](index), &value);
+        }
 
-        std::string toString() const;
+        /*! Replaces the item at index. */
+        inline void replace(size_t index, const Value &value) { replace(index, value.data()); }
+
+        inline ValueData &operator[](size_t index)
+        {
+            assert(index >= 0 && index < size());
+            return m_dataPtr->operator[](index);
+        }
+
+        /*! Joins the list items with spaces or without any separator if there are only digits and stores the result in dst. */
+        inline void toString(std::string &dst) const
+        {
+            dst.clear();
+            veque::veque<std::string> strings;
+            strings.reserve(m_size);
+            bool digits = true;
+            size_t i;
+
+            for (i = 0; i < m_size; i++) {
+                const ValueData *item = &m_dataPtr->operator[](i);
+                strings.push_back(std::string());
+                value_toString(item, &strings.back());
+
+                if (value_isValidNumber(item) && !strings.back().empty()) {
+                    double doubleNum = value_toDouble(item);
+                    long num = value_toLong(item);
+
+                    if (doubleNum != num) {
+                        digits = false;
+                        break;
+                    }
+
+                    if (num < 0 || num >= 10) {
+                        digits = false;
+                        break;
+                    }
+                } else {
+                    digits = false;
+                    break;
+                }
+            }
+
+            std::string s;
+
+            if (digits) {
+                for (i = 0; i < strings.size(); i++)
+                    dst.append(strings[i]);
+
+                for (; i < m_size; i++) {
+                    value_toString(&m_dataPtr->operator[](i), &s);
+                    dst.append(s);
+                }
+            } else {
+                for (i = 0; i < strings.size(); i++) {
+                    dst.append(strings[i]);
+
+                    if (i + 1 < m_size)
+                        dst.push_back(' ');
+                }
+
+                for (; i < m_size; i++) {
+                    value_toString(&m_dataPtr->operator[](i), &s);
+                    dst.append(s);
+
+                    if (i + 1 < m_size)
+                        dst.push_back(' ');
+                }
+            }
+        }
+
+        /*! Same as the other method, but returns the result directly. */
+        inline std::string toString() const
+        {
+            std::string ret;
+            toString(ret);
+            return ret;
+        }
 
         std::shared_ptr<List> clone();
 
     private:
+        inline void reserve(size_t size)
+        {
+            assert(size >= m_size);
+
+            while (size > m_dataPtr->size()) {
+                m_dataPtr->push_back(ValueData());
+                value_init(&m_dataPtr->back());
+            }
+
+            while (size < m_dataPtr->size()) {
+                value_free(&m_dataPtr->back());
+                m_dataPtr->erase(m_dataPtr->end());
+            }
+        }
+
+        inline size_t getAllocSize(size_t x)
+        {
+            if (x == 0)
+                return 0;
+
+            size_t ret = 1;
+
+            while (ret < x)
+                ret *= 2;
+
+            return ret;
+        }
+
         spimpl::unique_impl_ptr<ListPrivate> impl;
+        veque::veque<ValueData> *m_dataPtr = nullptr; // NOTE: accessing through pointer is faster! (from benchmarks)
+        size_t m_size = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/monitor.h b/include/scratchcpp/monitor.h
index 6fd84a41..85f5c8e4 100644
--- a/include/scratchcpp/monitor.h
+++ b/include/scratchcpp/monitor.h
@@ -12,7 +12,7 @@ namespace libscratchcpp
 class IMonitorHandler;
 class Block;
 class Script;
-class IBlockSection;
+class IExtension;
 class Sprite;
 class Value;
 class Rect;
@@ -48,8 +48,8 @@ class LIBSCRATCHCPP_EXPORT Monitor : public Entity
         std::shared_ptr<Script> script() const;
         void setScript(std::shared_ptr<Script> script);
 
-        std::shared_ptr<IBlockSection> blockSection() const;
-        void setBlockSection(std::shared_ptr<IBlockSection> blockSection);
+        IExtension *extension() const;
+        void setExtension(IExtension *extension);
 
         Sprite *sprite() const;
         void setSprite(Sprite *sprite);
@@ -85,9 +85,12 @@ class LIBSCRATCHCPP_EXPORT Monitor : public Entity
         bool discrete() const;
         void setDiscrete(bool discrete);
 
-        static Rect getInitialPosition(const std::vector<std::shared_ptr<Monitor>> &other, int monitorWidth, int monitorHeight);
+        bool needsAutoPosition() const;
+        void autoPosition(const std::vector<std::shared_ptr<Monitor>> &allMonitors);
 
     private:
+        static bool monitorRectsIntersect(const Rect &a, const Rect &b);
+
         spimpl::unique_impl_ptr<MonitorPrivate> impl;
 };
 
diff --git a/include/scratchcpp/rect.h b/include/scratchcpp/rect.h
index bf93c00f..cedcbe6e 100644
--- a/include/scratchcpp/rect.h
+++ b/include/scratchcpp/rect.h
@@ -32,6 +32,8 @@ class LIBSCRATCHCPP_EXPORT Rect
         double width() const;
         double height() const;
 
+        void snapToInt();
+
         bool intersects(const Rect &rect) const;
 
     private:
diff --git a/include/scratchcpp/scratchconfiguration.h b/include/scratchcpp/scratchconfiguration.h
index 991bdcdc..6fec5a59 100644
--- a/include/scratchcpp/scratchconfiguration.h
+++ b/include/scratchcpp/scratchconfiguration.h
@@ -21,6 +21,7 @@ class LIBSCRATCHCPP_EXPORT ScratchConfiguration
         ScratchConfiguration() = delete;
 
         static void registerExtension(std::shared_ptr<IExtension> extension);
+        static void removeExtension(std::shared_ptr<IExtension> extension);
         static IExtension *getExtension(const std::string &name);
 
         /*! Finds the extension of class T. Returns nullptr if it isn't registered. */
@@ -47,8 +48,9 @@ class LIBSCRATCHCPP_EXPORT ScratchConfiguration
 
     private:
         static const std::vector<std::shared_ptr<IExtension>> getExtensions();
+        static std::shared_ptr<ScratchConfigurationPrivate> &getImpl();
 
-        static std::unique_ptr<ScratchConfigurationPrivate> impl;
+        static inline std::shared_ptr<ScratchConfigurationPrivate> impl;
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index b82aaf48..dbf82b51 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -15,7 +15,7 @@ class Target;
 class Block;
 class IEngine;
 class Value;
-class VirtualMachine;
+class Thread;
 class Variable;
 class List;
 class ScriptPrivate;
@@ -42,8 +42,8 @@ class LIBSCRATCHCPP_EXPORT Script
         void setVariables(const std::vector<Variable *> &variables);
         void setLists(const std::vector<List *> &lists);
 
-        std::shared_ptr<VirtualMachine> start();
-        std::shared_ptr<VirtualMachine> start(Target *target);
+        std::shared_ptr<Thread> start();
+        std::shared_ptr<Thread> start(Target *target);
 
     private:
         BlockFunc *getFunctions() const;
diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
index 328c6371..f2f7d517 100644
--- a/include/scratchcpp/sprite.h
+++ b/include/scratchcpp/sprite.h
@@ -82,14 +82,12 @@ class LIBSCRATCHCPP_EXPORT Sprite
 
         bool touchingPoint(double x, double y) const override;
         bool touchingColor(const Value &color) const override;
+        bool touchingColor(const Value &color, const Value &mask) const override;
 
         void setGraphicsEffectValue(IGraphicsEffect *effect, double value) override;
 
         void clearGraphicsEffects() override;
 
-        virtual void setBubbleType(Target::BubbleType type) override;
-        virtual void setBubbleText(const std::string &text) override;
-
     private:
         Target *dataSource() const override;
         bool touchingClones(const std::vector<Sprite *> &clones) const override;
diff --git a/include/scratchcpp/stage.h b/include/scratchcpp/stage.h
index 0d37c862..3a0df955 100644
--- a/include/scratchcpp/stage.h
+++ b/include/scratchcpp/stage.h
@@ -56,14 +56,12 @@ class LIBSCRATCHCPP_EXPORT Stage : public Target
 
         bool touchingPoint(double x, double y) const override;
         bool touchingColor(const Value &color) const override;
+        bool touchingColor(const Value &color, const Value &mask) const override;
 
         void setGraphicsEffectValue(IGraphicsEffect *effect, double value) override;
 
         void clearGraphicsEffects() override;
 
-        virtual void setBubbleType(Target::BubbleType type) override;
-        virtual void setBubbleText(const std::string &text) override;
-
     private:
         bool touchingClones(const std::vector<Sprite *> &clones) const override;
 
diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index cb8f7c1b..50c2ec71 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -4,15 +4,13 @@
 
 #include <vector>
 
-#include "global.h"
-#include "spimpl.h"
+#include "drawable.h"
 #include "rect.h"
 #include "sound.h"
 
 namespace libscratchcpp
 {
 
-class IEngine;
 class Variable;
 class List;
 class Block;
@@ -20,23 +18,20 @@ class Comment;
 class Costume;
 class Sound;
 class Sprite;
+class TextBubble;
 class IGraphicsEffect;
 class TargetPrivate;
 
 /*! \brief The Target class is the Stage or a Sprite. */
-class LIBSCRATCHCPP_EXPORT Target
+class LIBSCRATCHCPP_EXPORT Target : public Drawable
 {
     public:
-        enum class BubbleType
-        {
-            Say,
-            Think
-        };
-
         Target();
         Target(const Target &) = delete;
         virtual ~Target() { }
 
+        bool isTarget() const override final;
+
         /*! Returns true if this Target is the stage. */
         virtual bool isStage() const { return false; }
 
@@ -83,9 +78,6 @@ class LIBSCRATCHCPP_EXPORT Target
         std::shared_ptr<Sound> soundAt(int index) const;
         int findSound(const std::string &soundName) const;
 
-        int layerOrder() const;
-        virtual void setLayerOrder(int newLayerOrder);
-
         double volume() const;
         void setVolume(double newVolume);
 
@@ -101,20 +93,17 @@ class LIBSCRATCHCPP_EXPORT Target
         virtual bool touchingPoint(double x, double y) const;
         bool touchingEdge() const;
         virtual bool touchingColor(const Value &color) const;
+        virtual bool touchingColor(const Value &color, const Value &mask) const;
 
         double graphicsEffectValue(IGraphicsEffect *effect) const;
         virtual void setGraphicsEffectValue(IGraphicsEffect *effect, double value);
 
         virtual void clearGraphicsEffects();
 
-        BubbleType bubbleType() const;
-        virtual void setBubbleType(BubbleType type);
-
-        const std::string &bubbleText() const;
-        virtual void setBubbleText(const std::string &text);
+        TextBubble *bubble();
+        const TextBubble *bubble() const;
 
-        IEngine *engine() const;
-        void setEngine(IEngine *engine);
+        void setEngine(IEngine *engine) override final;
 
     protected:
         /*! Override this method to set a custom data source for blocks, assets, comments, etc. */
diff --git a/include/scratchcpp/textbubble.h b/include/scratchcpp/textbubble.h
new file mode 100644
index 00000000..ce5395f1
--- /dev/null
+++ b/include/scratchcpp/textbubble.h
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "drawable.h"
+#include "signal.h"
+
+namespace libscratchcpp
+{
+
+class TextBubblePrivate;
+
+/*! \brief The TextBubble class represents a text bubble created using say or think block. */
+class TextBubble : public Drawable
+{
+    public:
+        enum class Type
+        {
+            Say,
+            Think
+        };
+
+        TextBubble();
+        TextBubble(const TextBubble &) = delete;
+
+        bool isTextBubble() const override final;
+
+        Type type() const;
+        virtual void setType(Type type);
+        sigslot::signal<Type> &typeChanged() const;
+
+        const std::string &text() const;
+        virtual void setText(const std::string &text);
+        sigslot::signal<const std::string &> &textChanged() const;
+
+    private:
+        spimpl::unique_impl_ptr<TextBubblePrivate> impl;
+};
+
+} // namespace libscratchcpp
diff --git a/include/scratchcpp/thread.h b/include/scratchcpp/thread.h
new file mode 100644
index 00000000..f3f7693e
--- /dev/null
+++ b/include/scratchcpp/thread.h
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "global.h"
+#include "spimpl.h"
+
+namespace libscratchcpp
+{
+
+class VirtualMachine;
+class Target;
+class IEngine;
+class Script;
+class ThreadPrivate;
+
+/*! \brief The Thread class represents a running Scratch script. */
+class LIBSCRATCHCPP_EXPORT Thread
+{
+    public:
+        Thread(Target *target, IEngine *engine, Script *script);
+        Thread(const Thread &) = delete;
+
+        VirtualMachine *vm() const;
+        Target *target() const;
+        IEngine *engine() const;
+        Script *script() const;
+
+        void run();
+        void kill();
+        void reset();
+
+        bool isFinished() const;
+
+        void promise();
+        void resolvePromise();
+
+    private:
+        spimpl::unique_impl_ptr<ThreadPrivate> impl;
+};
+
+} // namespace libscratchcpp
diff --git a/include/scratchcpp/value.h b/include/scratchcpp/value.h
index 94baeb55..df4db60e 100644
--- a/include/scratchcpp/value.h
+++ b/include/scratchcpp/value.h
@@ -2,7 +2,6 @@
 
 #pragma once
 
-#include <string>
 #include <algorithm>
 #include <limits>
 #include <ctgmath>
@@ -11,7 +10,9 @@
 #include <iostream>
 #include <clocale>
 
-#include "global.h"
+#include "value_functions.h"
+
+// NOTE: Put all logic in value functions so we can keep using this class in unit tests
 
 namespace libscratchcpp
 {
@@ -20,726 +21,230 @@ namespace libscratchcpp
 class LIBSCRATCHCPP_EXPORT Value
 {
     public:
-        enum class SpecialValue
-        {
-            Infinity,
-            NegativeInfinity,
-            NaN
-        };
-
-        enum class Type
-        {
-            Integer = 0,
-            Double = 1,
-            Bool = 2,
-            String = 3,
-            Infinity = -1,
-            NegativeInfinity = -2,
-            NaN = -3
-        };
-
         /*! Constructs a number Value. */
-        Value(float numberValue) :
-            m_type(Type::Double)
+        Value(float numberValue)
         {
-            if (isInf(numberValue))
-                m_type = Type::Infinity;
-            else if (isNegativeInf(numberValue))
-                m_type = Type::NegativeInfinity;
-            else if (std::isnan(numberValue))
-                m_type = Type::NaN;
-            else
-                m_doubleValue = floatToDouble(numberValue);
+            value_init(&m_data);
+            value_assign_float(&m_data, numberValue);
         }
 
         /*! Constructs a number Value. */
-        Value(double numberValue) :
-            m_type(Type::Double)
+        Value(double numberValue)
         {
-            if (isInf(numberValue))
-                m_type = Type::Infinity;
-            else if (isNegativeInf(numberValue))
-                m_type = Type::NegativeInfinity;
-            else if (std::isnan(numberValue))
-                m_type = Type::NaN;
-            else
-                m_doubleValue = numberValue;
+            value_init(&m_data);
+            value_assign_double(&m_data, numberValue);
         }
 
         /*! Constructs a number Value. */
-        Value(int numberValue = 0) :
-            m_type(Type::Integer)
+        Value(int numberValue = 0)
         {
-            m_intValue = numberValue;
+            value_init(&m_data);
+            value_assign_int(&m_data, numberValue);
         }
 
         /*! Constructs a number Value. */
-        Value(size_t numberValue) :
-            m_type(Type::Integer)
+        Value(size_t numberValue)
         {
-            m_intValue = numberValue;
+            value_init(&m_data);
+            value_assign_size_t(&m_data, numberValue);
         }
 
         /*! Constructs a number Value. */
-        Value(long numberValue) :
-            m_type(Type::Integer)
+        Value(long numberValue)
         {
-            m_intValue = numberValue;
+            value_init(&m_data);
+            value_assign_long(&m_data, numberValue);
         }
 
         /*! Constructs a boolean Value. */
-        Value(bool boolValue) :
-            m_type(Type::Bool)
+        Value(bool boolValue)
         {
-            m_boolValue = boolValue;
+            value_init(&m_data);
+            value_assign_bool(&m_data, boolValue);
         }
 
         /*! Constructs a string Value. */
-        Value(const std::string &stringValue) :
-            m_type(Type::String)
+        Value(const std::string &stringValue)
         {
-            if (stringValue == "Infinity")
-                m_type = Type::Infinity;
-            else if (stringValue == "-Infinity")
-                m_type = Type::NegativeInfinity;
-            else if (stringValue == "NaN")
-                m_type = Type::NaN;
-            else
-                new (&m_stringValue) std::string(stringValue);
+            value_init(&m_data);
+            value_assign_string(&m_data, stringValue);
         }
 
         /*! Constructs a string Value. */
-        Value(const char *stringValue) :
-            Value(std::string(stringValue))
+        Value(const char *stringValue)
         {
+            value_init(&m_data);
+            value_assign_cstring(&m_data, stringValue);
         }
 
         /*! Constructs a special Value. */
         Value(SpecialValue specialValue)
         {
-            if (specialValue == SpecialValue::Infinity)
-                m_type = Type::Infinity;
-            else if (specialValue == SpecialValue::NegativeInfinity)
-                m_type = Type::NegativeInfinity;
-            else if (specialValue == SpecialValue::NaN)
-                m_type = Type::NaN;
-            else {
-                m_type = Type::Integer;
-                m_intValue = 0;
-            }
+            value_init(&m_data);
+            value_assign_special(&m_data, specialValue);
         }
 
-        Value(const Value &v)
+        /*! Constructs value from ValueData. */
+        Value(const ValueData &v)
         {
-            m_type = v.m_type;
-
-            switch (m_type) {
-                case Type::Integer:
-                    m_intValue = v.m_intValue;
-                    break;
-                case Type::Double:
-                    m_doubleValue = v.m_doubleValue;
-                    break;
-                case Type::Bool:
-                    m_boolValue = v.m_boolValue;
-                    break;
-                case Type::String:
-                    new (&m_stringValue) std::string(v.m_stringValue);
-                    break;
-                default:
-                    break;
-            }
+            value_init(&m_data);
+            value_assign_copy(&m_data, &v);
         }
 
-        ~Value()
+        Value(const Value &v)
         {
-            if (m_type == Type::String)
-                m_stringValue.~basic_string();
+            value_init(&m_data);
+            value_assign_copy(&m_data, &v.m_data);
         }
 
+        ~Value() { value_free(&m_data); }
+
+        /*!
+         * Returns a read-only reference to the data.
+         * \note Valid until the Value object is destroyed.
+         */
+        const ValueData &data() const { return m_data; };
+
+        /*!
+         * Returns a read/write reference to the data.
+         * \note Valid until the Value object is destroyed.
+         */
+        ValueData &data() { return m_data; }
+
         /*! Returns the type of the value. */
-        Type type() const { return m_type; }
+        ValueType type() const { return m_data.type; }
 
         /*! Returns true if the value is infinity. */
-        bool isInfinity() const
-        {
-            switch (m_type) {
-                case Type::Infinity:
-                    return true;
-                case Type::Integer:
-                    return isInf(m_intValue);
-                case Type::Double:
-                    return isInf(m_doubleValue);
-                case Type::String:
-                    return m_stringValue == "Infinity";
-                default:
-                    return false;
-            }
-        }
+        bool isInfinity() const { return value_isInfinity(&m_data); }
 
         /*! Returns true if the value is negative infinity. */
-        bool isNegativeInfinity() const
-        {
-            switch (m_type) {
-                case Type::NegativeInfinity:
-                    return true;
-                case Type::Integer:
-                    return isNegativeInf(-m_intValue);
-                case Type::Double:
-                    return isNegativeInf(-m_doubleValue);
-                case Type::String:
-                    return m_stringValue == "-Infinity";
-                default:
-                    return false;
-            }
-        }
+        bool isNegativeInfinity() const { return value_isNegativeInfinity(&m_data); }
 
         /*! Returns true if the value is NaN (Not a Number). */
-        bool isNaN() const
-        {
-            switch (m_type) {
-                case Type::NaN:
-                    return true;
-                case Type::Double:
-                    assert(!std::isnan(m_doubleValue));
-                    return std::isnan(m_doubleValue);
-                case Type::String:
-                    return m_stringValue == "NaN";
-                default:
-                    return false;
-            }
-        }
+        bool isNaN() const { return value_isNaN(&m_data); }
 
         /*! Returns true if the value is a number. */
-        bool isNumber() const { return m_type == Type::Integer || m_type == Type::Double; }
+        bool isNumber() const { return value_isNumber(&m_data); }
 
         /*! Returns true if the value is a number or can be converted to a number. */
-        bool isValidNumber() const
-        {
-            if (isNaN())
-                return false;
-
-            if (isInfinity() || isNegativeInfinity())
-                return true;
-
-            assert(m_type != Type::Infinity && m_type != Type::NegativeInfinity);
-
-            switch (m_type) {
-                case Type::Integer:
-                case Type::Double:
-                case Type::Bool:
-                    return true;
-                case Type::String:
-                    return m_stringValue.empty() || checkString(m_stringValue) > 0;
-                default:
-                    return false;
-            }
-        }
+        bool isValidNumber() const { return value_isValidNumber(&m_data); }
 
         /*! Returns true if this value represents a round integer. */
-        bool isInt() const
-        {
-            // https://github.com/scratchfoundation/scratch-vm/blob/112989da0e7306eeb405a5c52616e41c2164af24/src/util/cast.js#L157-L181
-            switch (m_type) {
-                case Type::Integer:
-                case Type::Bool:
-                case Type::Infinity:
-                case Type::NegativeInfinity:
-                case Type::NaN:
-                    return true;
-                case Type::Double: {
-                    double intpart;
-                    std::modf(m_doubleValue, &intpart);
-                    return m_doubleValue == intpart;
-                }
-                case Type::String:
-                    return m_stringValue.find('.') == std::string::npos;
-            }
-
-            return false;
-        }
+        bool isInt() const { return value_isInt(&m_data); }
 
         /*! Returns true if the value is a boolean. */
-        bool isBool() const { return m_type == Type::Bool; }
+        bool isBool() const { return value_isBool(&m_data); }
 
         /*! Returns true if the value is a string. */
-        bool isString() const { return m_type == Type::String; }
+        bool isString() const { return value_isString(&m_data); }
 
         /*! Returns the int representation of the value. */
-        int toInt() const { return toLong(); }
+        int toInt() const { return value_toInt(&m_data); }
 
         /*! Returns the long representation of the value. */
-        long toLong() const
-        {
-            if (static_cast<int>(m_type) < 0)
-                return 0;
-            else {
-                switch (m_type) {
-                    case Type::Integer:
-                        return m_intValue;
-                    case Type::Double:
-                        return m_doubleValue;
-                    case Type::Bool:
-                        return m_boolValue;
-                    case Type::String:
-                        return stringToLong(m_stringValue);
-                    default:
-                        return 0;
-                }
-            }
-        }
+        long toLong() const { return value_toLong(&m_data); }
 
         /*! Returns the double representation of the value. */
-        double toDouble() const
-        {
-            if (static_cast<int>(m_type) < 0) {
-                switch (m_type) {
-                    case Type::Infinity:
-                        return std::numeric_limits<double>::infinity();
-                    case Type::NegativeInfinity:
-                        return -std::numeric_limits<double>::infinity();
-                    default:
-                        return 0;
-                }
-            } else {
-                switch (m_type) {
-                    case Type::Double:
-                        return m_doubleValue;
-                    case Type::Integer:
-                        return m_intValue;
-                    case Type::Bool:
-                        return m_boolValue;
-                    case Type::String:
-                        return stringToDouble(m_stringValue);
-                    default:
-                        return 0;
-                }
-            }
-        };
+        double toDouble() const { return value_toDouble(&m_data); };
 
         /*! Returns the boolean representation of the value. */
-        bool toBool() const
-        {
-            switch (m_type) {
-                case Type::Bool:
-                    return m_boolValue;
-                case Type::Integer:
-                    return m_intValue != 0;
-                case Type::Double:
-                    return m_doubleValue != 0;
-                case Type::String:
-                    return !m_stringValue.empty() && !stringsEqual(m_stringValue, "false") && m_stringValue != "0";
-                case Type::Infinity:
-                case Type::NegativeInfinity:
-                    return true;
-                case Type::NaN:
-                    return false;
-                default:
-                    return false;
-            }
-        };
+        bool toBool() const { return value_toBool(&m_data); };
 
         /*! Returns the string representation of the value. */
         std::string toString() const
         {
-            if (static_cast<int>(m_type) < 0) {
-                switch (m_type) {
-                    case Type::Infinity:
-                        return "Infinity";
-                    case Type::NegativeInfinity:
-                        return "-Infinity";
-                    default:
-                        return "NaN";
-                }
-            } else {
-                switch (m_type) {
-                    case Type::String:
-                        return m_stringValue;
-                    case Type::Integer:
-                        return std::to_string(m_intValue);
-                    case Type::Double: {
-                        return doubleToString(m_doubleValue);
-                    }
-                    case Type::Bool:
-                        return m_boolValue ? "true" : "false";
-                    default:
-                        return "";
-                }
-            }
+            std::string ret;
+            value_toString(&m_data, &ret);
+            return ret;
         };
 
         /*! Returns the UTF-16 representation of the value. */
-        std::u16string toUtf16() const;
-
-        /*! Adds the given value to the value. */
-        void add(const Value &v)
+        std::u16string toUtf16()
         {
-            if ((static_cast<int>(m_type) < 0) || (static_cast<int>(v.m_type) < 0)) {
-                if ((m_type == Type::Infinity && v.m_type == Type::NegativeInfinity) || (m_type == Type::NegativeInfinity && v.m_type == Type::Infinity))
-                    m_type = Type::NaN;
-                else if (m_type == Type::Infinity || v.m_type == Type::Infinity)
-                    m_type = Type::Infinity;
-                else if (m_type == Type::NegativeInfinity || v.m_type == Type::NegativeInfinity)
-                    m_type = Type::NegativeInfinity;
-                return;
-            }
-
-            if (m_type == Type::Integer && v.m_type == Type::Integer)
-                m_intValue += v.m_intValue;
-            else
-                *this = toDouble() + v.toDouble();
+            std::u16string ret;
+            value_toUtf16(&m_data, &ret);
+            return ret;
         }
 
-        /*! Subtracts the given value from the value. */
-        void subtract(const Value &v)
-        {
-            if ((static_cast<int>(m_type) < 0) || (static_cast<int>(v.m_type) < 0)) {
-                if ((m_type == Type::Infinity && v.m_type == Type::Infinity) || (m_type == Type::NegativeInfinity && v.m_type == Type::NegativeInfinity))
-                    m_type = Type::NaN;
-                else if (m_type == Type::Infinity || v.m_type == Type::NegativeInfinity)
-                    m_type = Type::Infinity;
-                else if (m_type == Type::NegativeInfinity || v.m_type == Type::Infinity)
-                    m_type = Type::NegativeInfinity;
-                return;
-            }
+        /*! Adds the given value to the value. */
+        void add(const Value &v) { value_add(&m_data, &v.m_data, &m_data); }
 
-            if (m_type == Type::Integer && v.m_type == Type::Integer)
-                m_intValue -= v.m_intValue;
-            else
-                *this = toDouble() - v.toDouble();
-        }
+        /*! Subtracts the given value from the value. */
+        void subtract(const Value &v) { value_subtract(&m_data, &v.m_data, &m_data); }
 
         /*! Multiplies the given value with the value. */
-        void multiply(const Value &v)
-        {
-            Type t1 = m_type, t2 = v.m_type;
-            if ((static_cast<int>(t1) < 0 && t1 != Type::NaN) || (static_cast<int>(t2) < 0 && t2 != Type::NaN)) {
-                if (t1 == Type::Infinity || t1 == Type::NegativeInfinity || t2 == Type::Infinity || t2 == Type::NegativeInfinity) {
-                    bool mode = (t1 == Type::Infinity || t2 == Type::Infinity);
-                    const Value &value = ((t1 == Type::Infinity && (t2 == Type::Infinity || t2 == Type::NegativeInfinity)) || (t2 != Type::Infinity && t2 != Type::NegativeInfinity)) ? v : *this;
-                    if (value > 0)
-                        m_type = mode ? Type::Infinity : Type::NegativeInfinity;
-                    else if (value < 0)
-                        m_type = mode ? Type::NegativeInfinity : Type::Infinity;
-                    else
-                        m_type = Type::NaN;
-                    return;
-                }
-            }
-
-            if (m_type == Type::Integer && v.m_type == Type::Integer)
-                m_intValue *= v.m_intValue;
-            else
-                *this = toDouble() * v.toDouble();
-        }
+        void multiply(const Value &v) { value_multiply(&m_data, &v.m_data, &m_data); }
 
         /*! Divides the value by the given value. */
-        void divide(const Value &v)
-        {
-            if ((toDouble() == 0) && (v.toDouble() == 0)) {
-                m_type = Type::NaN;
-                return;
-            } else if (v.toDouble() == 0) {
-                m_type = *this > 0 ? Type::Infinity : Type::NegativeInfinity;
-                return;
-            } else if ((m_type == Type::Infinity || m_type == Type::NegativeInfinity) && (v.m_type == Type::Infinity || v.m_type == Type::NegativeInfinity)) {
-                m_type = Type::NaN;
-                return;
-            } else if (m_type == Type::Infinity || m_type == Type::NegativeInfinity) {
-                if (v.toDouble() < 0)
-                    m_type = m_type == Type::Infinity ? Type::NegativeInfinity : Type::Infinity;
-                return;
-            } else if (v.m_type == Type::Infinity || v.m_type == Type::NegativeInfinity) {
-                *this = 0;
-                return;
-            }
-            *this = toDouble() / v.toDouble();
-        }
+        void divide(const Value &v) { value_divide(&m_data, &v.m_data, &m_data); }
 
         /*! Replaces the value with modulo of the value and the given value. */
-        void mod(const Value &v)
-        {
-            if ((v == 0) || (m_type == Type::Infinity || m_type == Type::NegativeInfinity)) {
-                m_type = Type::NaN;
-                return;
-            } else if (v.m_type == Type::Infinity || v.m_type == Type::NegativeInfinity) {
-                return;
-            }
-            if (*this < 0 || v < 0)
-                *this = fmod(v.toDouble() + fmod(toDouble(), -v.toDouble()), v.toDouble());
-            else
-                *this = fmod(toDouble(), v.toDouble());
-        }
+        void mod(const Value &v) { value_mod(&m_data, &v.m_data, &m_data); }
 
         const Value &operator=(float v)
         {
-            if (m_type == Type::String)
-                m_stringValue.~basic_string();
-
-            if (isInf(v))
-                m_type = Type::Infinity;
-            else if (isNegativeInf(v))
-                m_type = Type::NegativeInfinity;
-            else if (std::isnan(v))
-                m_type = Type::NaN;
-            else {
-                m_type = Type::Double;
-                m_doubleValue = floatToDouble(v);
-            }
-
+            value_assign_float(&m_data, v);
             return *this;
         }
 
         const Value &operator=(double v)
         {
-            if (m_type == Type::String)
-                m_stringValue.~basic_string();
-
-            if (isInf(v))
-                m_type = Type::Infinity;
-            else if (isNegativeInf(v))
-                m_type = Type::NegativeInfinity;
-            else if (std::isnan(v))
-                m_type = Type::NaN;
-            else {
-                m_type = Type::Double;
-                m_doubleValue = v;
-            }
+            value_assign_double(&m_data, v);
             return *this;
         }
 
         const Value &operator=(int v)
         {
-            if (m_type == Type::String)
-                m_stringValue.~basic_string();
-
-            m_type = Type::Integer;
-            m_intValue = v;
+            value_assign_int(&m_data, v);
             return *this;
         }
 
         const Value &operator=(long v)
         {
-            if (m_type == Type::String)
-                m_stringValue.~basic_string();
-
-            m_type = Type::Integer;
-            m_intValue = v;
+            value_assign_long(&m_data, v);
             return *this;
         }
 
         const Value &operator=(bool v)
         {
-            if (m_type == Type::String)
-                m_stringValue.~basic_string();
-
-            m_type = Type::Bool;
-            m_boolValue = v;
+            value_assign_bool(&m_data, v);
             return *this;
         }
 
         const Value &operator=(const std::string &v)
         {
-            if (v == "Infinity") {
-                if (m_type == Type::String)
-                    m_stringValue.~basic_string();
-
-                m_type = Type::Infinity;
-            } else if (v == "-Infinity") {
-                if (m_type == Type::String)
-                    m_stringValue.~basic_string();
-
-                m_type = Type::NegativeInfinity;
-            } else if (v == "NaN") {
-                if (m_type == Type::String)
-                    m_stringValue.~basic_string();
-
-                m_type = Type::NaN;
-            } else if (m_type == Type::String)
-                m_stringValue = v;
-            else {
-                new (&m_stringValue) std::string(v);
-                m_type = Type::String;
-            }
-
+            value_assign_string(&m_data, v);
             return *this;
         }
 
-        const Value &operator=(const char *v) { return (*this = std::string(v)); }
-
-        const Value &operator=(const Value &v)
+        const Value &operator=(const char *v)
         {
-            switch (v.m_type) {
-                case Type::Integer:
-                    if (m_type == Type::String)
-                        m_stringValue.~basic_string();
-
-                    m_intValue = v.m_intValue;
-                    break;
-
-                case Type::Double:
-                    if (m_type == Type::String)
-                        m_stringValue.~basic_string();
-
-                    m_doubleValue = v.m_doubleValue;
-                    break;
-
-                case Type::Bool:
-                    if (m_type == Type::String)
-                        m_stringValue.~basic_string();
-
-                    m_boolValue = v.m_boolValue;
-                    break;
-
-                case Type::String:
-                    if (m_type == Type::String)
-                        m_stringValue = v.m_stringValue;
-                    else
-                        new (&m_stringValue) std::string(v.m_stringValue);
-                    break;
-
-                default:
-                    break;
-            }
-
-            m_type = v.m_type;
-
+            value_assign_cstring(&m_data, v);
             return *this;
         }
 
-    private:
-        union
-        {
-                long m_intValue;
-                double m_doubleValue;
-                bool m_boolValue;
-                std::string m_stringValue;
-        };
-
-        // 0 - is string
-        // 1 - is long
-        // 2 - is double
-        static int checkString(const std::string &str)
-        {
-            bool ok;
-
-            if ((str.find_first_of('.') == std::string::npos) && (str.find_first_of('e') == std::string::npos) && (str.find_first_of('E') == std::string::npos)) {
-                stringToLong(str, &ok);
-                return ok ? 1 : 0;
-            } else {
-                stringToDouble(str, &ok);
-                return ok ? 2 : 0;
-            }
-        }
-
-        double getNumber(bool *ok = nullptr) const
+        const Value &operator=(const ValueData &v)
         {
-            // Equivalent to JavaScript Number(), *ok == false means NaN
-            if (ok)
-                *ok = true;
-
-            switch (m_type) {
-                case Type::Integer:
-                    return m_intValue;
-
-                case Type::Double:
-                    return m_doubleValue;
-
-                case Type::Bool:
-                    return m_boolValue;
-
-                case Type::String:
-                    return stringToDouble(m_stringValue, ok);
-
-                case Type::Infinity:
-                    return std::numeric_limits<double>::infinity();
-
-                case Type::NegativeInfinity:
-                    return -std::numeric_limits<double>::infinity();
-
-                case Type::NaN:
-                    if (ok)
-                        *ok = false;
-
-                    return 0;
-
-                default:
-                    assert(false); // this should never happen
-                    if (ok)
-                        *ok = false;
-
-                    return 0;
-            }
+            value_assign_copy(&m_data, &v);
+            return *this;
         }
 
-        Type m_type;
-
-        friend bool operator==(const Value &v1, const Value &v2)
+        const Value &operator=(const Value &v)
         {
-            // https://github.com/scratchfoundation/scratch-vm/blob/112989da0e7306eeb405a5c52616e41c2164af24/src/util/cast.js#L121-L150
-            bool ok;
-            double n1 = v1.getNumber(&ok);
-            double n2;
-
-            if (ok)
-                n2 = v2.getNumber(&ok);
-
-            if (!ok) {
-                // At least one argument can't be converted to a number
-                // Scratch compares strings as case insensitive
-                return stringsEqual(v1.toUtf16(), v2.toUtf16());
-            }
-
-            // Handle the special case of Infinity
-            if ((static_cast<int>(v1.m_type) < 0) && (static_cast<int>(v2.m_type) < 0)) {
-                assert(v1.m_type != Type::NaN);
-                assert(v2.m_type != Type::NaN);
-                return v1.m_type == v2.m_type;
-            }
-
-            // Compare as numbers
-            return n1 == n2;
+            value_assign_copy(&m_data, &v.m_data);
+            return *this;
         }
 
-        friend bool operator!=(const Value &v1, const Value &v2) { return !(v1 == v2); }
+    private:
+        ValueData m_data;
 
-        friend bool operator>(const Value &v1, const Value &v2)
-        {
-            if ((static_cast<int>(v1.m_type) < 0) || (static_cast<int>(v2.m_type) < 0)) {
-                if (v1.m_type == Type::Infinity) {
-                    return v2.m_type != Type::Infinity;
-                } else if (v1.m_type == Type::NegativeInfinity)
-                    return false;
-                else if (v2.m_type == Type::Infinity)
-                    return false;
-                else if (v2.m_type == Type::NegativeInfinity)
-                    return true;
-            }
+        friend bool operator==(const Value &v1, const Value &v2) { return value_equals(&v1.m_data, &v2.m_data); }
 
-            if (v1.m_type == Type::Integer && v2.m_type == Type::Integer)
-                return v1.m_intValue > v2.m_intValue;
-            else
-                return v1.toDouble() > v2.toDouble();
-        }
+        friend bool operator!=(const Value &v1, const Value &v2) { return !value_equals(&v1.m_data, &v2.m_data); }
 
-        friend bool operator<(const Value &v1, const Value &v2)
-        {
-            if ((static_cast<int>(v1.m_type) < 0) || (static_cast<int>(v2.m_type) < 0)) {
-                if (v1.m_type == Type::Infinity) {
-                    return false;
-                } else if (v1.m_type == Type::NegativeInfinity)
-                    return v2.m_type != Type::NegativeInfinity;
-                else if (v2.m_type == Type::Infinity)
-                    return v1.m_type != Type::Infinity;
-                else if (v2.m_type == Type::NegativeInfinity)
-                    return false;
-            }
+        friend bool operator>(const Value &v1, const Value &v2) { return value_greater(&v1.m_data, &v2.m_data); }
 
-            if (v1.m_type == Type::Integer && v2.m_type == Type::Integer)
-                return v1.m_intValue < v2.m_intValue;
-            else
-                return v1.toDouble() < v2.toDouble();
-        }
+        friend bool operator<(const Value &v1, const Value &v2) { return value_lower(&v1.m_data, &v2.m_data); }
 
         friend bool operator>=(const Value &v1, const Value &v2) { return v1 > v2 || v1 == v2; }
 
@@ -747,351 +252,38 @@ class LIBSCRATCHCPP_EXPORT Value
 
         friend Value operator+(const Value &v1, const Value &v2)
         {
-            if ((static_cast<int>(v1.m_type) < 0) || (static_cast<int>(v2.m_type) < 0)) {
-                if ((v1.m_type == Type::Infinity && v2.m_type == Type::NegativeInfinity) || (v1.m_type == Type::NegativeInfinity && v2.m_type == Type::Infinity))
-                    return Value(SpecialValue::NaN);
-                else if (v1.m_type == Type::Infinity || v2.m_type == Type::Infinity)
-                    return Value(SpecialValue::Infinity);
-                else if (v1.m_type == Type::NegativeInfinity || v2.m_type == Type::NegativeInfinity)
-                    return Value(SpecialValue::NegativeInfinity);
-            }
-
-            if (v1.m_type == Type::Integer && v2.m_type == Type::Integer)
-                return v1.m_intValue + v2.m_intValue;
-            else
-                return v1.toDouble() + v2.toDouble();
+            Value ret;
+            value_add(&v1.m_data, &v2.m_data, &ret.m_data);
+            return ret;
         }
 
         friend Value operator-(const Value &v1, const Value &v2)
         {
-            if ((static_cast<int>(v1.m_type) < 0) || (static_cast<int>(v2.m_type) < 0)) {
-                if ((v1.m_type == Type::Infinity && v2.m_type == Type::Infinity) || (v1.m_type == Type::NegativeInfinity && v2.m_type == Type::NegativeInfinity))
-                    return Value(SpecialValue::NaN);
-                else if (v1.m_type == Type::Infinity || v2.m_type == Type::NegativeInfinity)
-                    return Value(SpecialValue::Infinity);
-                else if (v1.m_type == Type::NegativeInfinity || v2.m_type == Type::Infinity)
-                    return Value(SpecialValue::NegativeInfinity);
-            }
-
-            if (v1.m_type == Type::Integer && v2.m_type == Type::Integer)
-                return v1.m_intValue - v2.m_intValue;
-            else
-                return v1.toDouble() - v2.toDouble();
+            Value ret;
+            value_subtract(&v1.m_data, &v2.m_data, &ret.m_data);
+            return ret;
         }
 
         friend Value operator*(const Value &v1, const Value &v2)
         {
-            Type t1 = v1.m_type, t2 = v2.m_type;
-            if ((static_cast<int>(t1) < 0 && t1 != Type::NaN) || (static_cast<int>(t2) < 0 && t2 != Type::NaN)) {
-                if (t1 == Type::Infinity || t1 == Type::NegativeInfinity || t2 == Type::Infinity || t2 == Type::NegativeInfinity) {
-                    bool mode = (t1 == Type::Infinity || t2 == Type::Infinity);
-                    const Value &value = ((t1 == Type::Infinity && (t2 == Type::Infinity || t2 == Type::NegativeInfinity)) || (t2 != Type::Infinity && t2 != Type::NegativeInfinity)) ? v2 : v1;
-                    if (value > 0)
-                        return Value(mode ? SpecialValue::Infinity : SpecialValue::NegativeInfinity);
-                    else if (value < 0)
-                        return Value(mode ? SpecialValue::NegativeInfinity : SpecialValue::Infinity);
-                    else
-                        return Value(SpecialValue::NaN);
-                }
-            }
-
-            if (v1.m_type == Type::Integer && v2.m_type == Type::Integer)
-                return v1.m_intValue * v2.m_intValue;
-            else
-                return v1.toDouble() * v2.toDouble();
+            Value ret;
+            value_multiply(&v1.m_data, &v2.m_data, &ret.m_data);
+            return ret;
         }
 
         friend Value operator/(const Value &v1, const Value &v2)
         {
-            if ((v1 == 0) && (v2 == 0))
-                return Value(SpecialValue::NaN);
-            else if (v2.toDouble() == 0)
-                return v1 > 0 ? Value(SpecialValue::Infinity) : Value(SpecialValue::NegativeInfinity);
-            else if ((v1.m_type == Type::Infinity || v1.m_type == Type::NegativeInfinity) && (v2.m_type == Type::Infinity || v2.m_type == Type::NegativeInfinity)) {
-                return Value(SpecialValue::NaN);
-            } else if (v1.m_type == Type::Infinity || v1.m_type == Type::NegativeInfinity) {
-                if (v2.toDouble() < 0)
-                    return v1.m_type == Type::Infinity ? Value(SpecialValue::NegativeInfinity) : Value(SpecialValue::Infinity);
-                else
-                    return v1.m_type == Type::Infinity ? Value(SpecialValue::Infinity) : Value(SpecialValue::NegativeInfinity);
-            } else if (v2.m_type == Type::Infinity || v2.m_type == Type::NegativeInfinity) {
-                return 0;
-            }
-            return v1.toDouble() / v2.toDouble();
-        }
-
-        friend Value operator%(const Value &v1, const Value &v2)
-        {
-
-            if ((v2 == 0) || (v1.m_type == Type::Infinity || v1.m_type == Type::NegativeInfinity))
-                return Value(SpecialValue::NaN);
-            else if (v2.m_type == Type::Infinity || v2.m_type == Type::NegativeInfinity) {
-                return v1.toDouble();
-            }
-            if (v1 < 0 || v2 < 0)
-                return fmod(v2.toDouble() + fmod(v1.toDouble(), -v2.toDouble()), v2.toDouble());
-            else
-                return fmod(v1.toDouble(), v2.toDouble());
-        }
-
-        static bool stringsEqual(std::u16string s1, std::u16string s2)
-        {
-            std::transform(s1.begin(), s1.end(), s1.begin(), ::tolower);
-            std::transform(s2.begin(), s2.end(), s2.begin(), ::tolower);
-            return (s1.compare(s2) == 0);
-        }
-
-        static bool stringsEqual(std::string s1, std::string s2)
-        {
-            std::transform(s1.begin(), s1.end(), s1.begin(), ::tolower);
-            std::transform(s2.begin(), s2.end(), s2.begin(), ::tolower);
-            return (s1.compare(s2) == 0);
-        }
-
-        static long hexToDec(const std::string &s)
-        {
-            static const std::string digits = "0123456789abcdef";
-
-            for (char c : s) {
-                if (digits.find(c) == std::string::npos) {
-                    return 0;
-                }
-            }
-
-            std::istringstream stream(s);
-            long ret;
-            stream >> std::hex >> ret;
+            Value ret;
+            value_divide(&v1.m_data, &v2.m_data, &ret.m_data);
             return ret;
         }
 
-        static long octToDec(const std::string &s)
+        friend Value operator%(const Value &v1, const Value &v2)
         {
-            static const std::string digits = "01234567";
-
-            for (char c : s) {
-                if (digits.find(c) == std::string::npos) {
-                    return 0;
-                }
-            }
-
-            std::istringstream stream(s);
-            long ret;
-            stream >> std::oct >> ret;
+            Value ret;
+            value_mod(&v1.m_data, &v2.m_data, &ret.m_data);
             return ret;
         }
-
-        static double binToDec(const std::string &s)
-        {
-            static const std::string digits = "01";
-
-            for (char c : s) {
-                if (digits.find(c) == std::string::npos) {
-                    return 0;
-                }
-            }
-
-            return std::stoi(s, 0, 2);
-        }
-
-        static double stringToDouble(const std::string &s, bool *ok = nullptr)
-        {
-            if (ok)
-                *ok = false;
-
-            if (s == "Infinity") {
-                if (ok)
-                    *ok = true;
-                return std::numeric_limits<double>::infinity();
-            } else if (s == "-Infinity") {
-                if (ok)
-                    *ok = true;
-                return -std::numeric_limits<double>::infinity();
-            } else if (s == "NaN") {
-                if (ok)
-                    *ok = true;
-                return 0;
-            }
-
-            if (s.size() >= 2 && s[0] == '0') {
-                std::string sub = s.substr(2, s.size() - 2);
-                std::transform(sub.begin(), sub.end(), sub.begin(), ::tolower);
-
-                if (s[1] == 'x' || s[1] == 'X') {
-                    return hexToDec(sub);
-                } else if (s[1] == 'o' || s[1] == 'O') {
-                    return octToDec(sub);
-                } else if (s[1] == 'b' || s[1] == 'B') {
-                    return binToDec(sub);
-                }
-            }
-
-            static const std::string digits = "0123456789.eE+-";
-            const std::string *stringPtr = &s;
-            bool customStr = false;
-
-            if (!s.empty() && ((s[0] == ' ') || (s.back() == ' '))) {
-                std::string *localPtr = new std::string(s);
-                stringPtr = localPtr;
-                customStr = true;
-
-                while (!localPtr->empty() && (localPtr->at(0) == ' '))
-                    localPtr->erase(0, 1);
-
-                while (!localPtr->empty() && (localPtr->back() == ' '))
-                    localPtr->pop_back();
-            }
-
-            for (char c : *stringPtr) {
-                if (digits.find(c) == std::string::npos) {
-                    return 0;
-                }
-            }
-
-            try {
-                if (ok)
-                    *ok = true;
-
-                // Set locale to C to avoid conversion issues
-                std::string oldLocale = std::setlocale(LC_NUMERIC, nullptr);
-                std::setlocale(LC_NUMERIC, "C");
-
-                double ret = std::stod(*stringPtr);
-
-                // Restore old locale
-                std::setlocale(LC_NUMERIC, oldLocale.c_str());
-
-                if (customStr)
-                    delete stringPtr;
-
-                return ret;
-            } catch (...) {
-                if (ok)
-                    *ok = false;
-                return 0;
-            }
-        }
-
-        static long stringToLong(const std::string &s, bool *ok = nullptr)
-        {
-            if (ok)
-                *ok = false;
-
-            if (s == "Infinity") {
-                if (ok)
-                    *ok = true;
-                return std::numeric_limits<long>::infinity();
-            } else if (s == "-Infinity") {
-                if (ok)
-                    *ok = true;
-                return -std::numeric_limits<long>::infinity();
-            } else if (s == "NaN") {
-                if (ok)
-                    *ok = true;
-                return 0;
-            }
-
-            if (s.size() >= 2 && s[0] == '0') {
-                std::string sub = s.substr(2, s.size() - 2);
-                std::transform(sub.begin(), sub.end(), sub.begin(), ::tolower);
-
-                if (s[1] == 'x' || s[1] == 'X') {
-                    return hexToDec(sub);
-                } else if (s[1] == 'o' || s[1] == 'O') {
-                    return octToDec(sub);
-                } else if (s[1] == 'b' || s[1] == 'B') {
-                    return binToDec(sub);
-                }
-            }
-
-            static const std::string digits = "0123456789.eE+-";
-
-            for (char c : s) {
-                if (digits.find(c) == std::string::npos) {
-                    return 0;
-                }
-            }
-
-            try {
-                if (ok)
-                    *ok = true;
-                return std::stol(s);
-            } catch (...) {
-                if (ok)
-                    *ok = false;
-                return 0;
-            }
-        }
-
-        static std::string doubleToString(double v)
-        {
-            std::stringstream stream;
-
-            if (v != 0) {
-                const int exponent = std::log10(std::abs(v));
-
-                if (exponent > 20)
-                    stream << std::scientific << std::setprecision(digitCount(v / std::pow(10, exponent + 1)) - 1) << v;
-                else
-                    stream << std::setprecision(std::max(16u, digitCount(v))) << v;
-            } else
-                stream << std::setprecision(std::max(16u, digitCount(v))) << v;
-
-            std::string s = stream.str();
-            std::size_t index;
-
-            for (int i = 0; i < 2; i++) {
-                if (i == 0)
-                    index = s.find("e+");
-                else
-                    index = s.find("e-");
-
-                if (index != std::string::npos) {
-                    while ((s.size() >= index + 3) && (s[index + 2] == '0'))
-                        s.erase(index + 2, 1);
-                }
-            }
-
-            return s;
-        }
-
-        static double floatToDouble(float v)
-        {
-            unsigned int digits = digitCount(v);
-            double f = std::pow(10, digits);
-            return std::round(v * f) / f;
-        }
-
-        template<typename T>
-        static unsigned int digitCount(T v)
-        {
-            const T epsilon = 0.0000001;
-            T intpart;
-            unsigned int i = 1, j = 0;
-
-            if (std::abs(std::modf(v, &intpart)) >= epsilon) {
-                T tmp_intpart;
-
-                while (std::abs(std::modf(v * std::pow(10, i), &tmp_intpart)) >= epsilon)
-                    i++;
-            }
-
-            while (std::abs(intpart / pow(10, j)) >= 1.0)
-                j++;
-
-            return i + j;
-        }
-
-        template<typename T>
-        static bool isInf(T v)
-        {
-            return v > 0 && std::isinf(v);
-        }
-
-        template<typename T>
-        static bool isNegativeInf(T v)
-        {
-            return v < 0 && std::isinf(v);
-        }
 };
 
 } // namespace libscratchcpp
diff --git a/include/scratchcpp/value_functions.h b/include/scratchcpp/value_functions.h
new file mode 100644
index 00000000..f5707166
--- /dev/null
+++ b/include/scratchcpp/value_functions.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "valuedata.h"
+
+namespace libscratchcpp
+{
+
+extern "C"
+{
+    LIBSCRATCHCPP_EXPORT void value_free(ValueData *v);
+
+    LIBSCRATCHCPP_EXPORT void value_init(ValueData *v);
+
+    LIBSCRATCHCPP_EXPORT void value_assign_float(ValueData *v, float numberValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_double(ValueData *v, double numberValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_int(ValueData *v, int numberValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_size_t(ValueData *v, size_t numberValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_long(ValueData *v, long numberValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_bool(ValueData *v, bool boolValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_string(ValueData *v, const std::string &stringValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_cstring(ValueData *v, const char *stringValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_special(ValueData *v, SpecialValue specialValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_copy(ValueData *v, const ValueData *another);
+
+    LIBSCRATCHCPP_EXPORT bool value_isInfinity(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT bool value_isNegativeInfinity(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT bool value_isNaN(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT bool value_isNumber(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT bool value_isValidNumber(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT bool value_isInt(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT bool value_isBool(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT bool value_isString(const ValueData *v);
+
+    LIBSCRATCHCPP_EXPORT long value_toLong(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT int value_toInt(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT double value_toDouble(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT bool value_toBool(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT void value_toString(const ValueData *v, std::string *dst);
+    LIBSCRATCHCPP_EXPORT void value_toUtf16(const ValueData *v, std::u16string *dst);
+
+    LIBSCRATCHCPP_EXPORT void value_add(const ValueData *v1, const ValueData *v2, ValueData *dst);
+    LIBSCRATCHCPP_EXPORT void value_subtract(const ValueData *v1, const ValueData *v2, ValueData *dst);
+    LIBSCRATCHCPP_EXPORT void value_multiply(const ValueData *v1, const ValueData *v2, ValueData *dst);
+    LIBSCRATCHCPP_EXPORT void value_divide(const ValueData *v1, const ValueData *v2, ValueData *dst);
+    LIBSCRATCHCPP_EXPORT void value_mod(const ValueData *v1, const ValueData *v2, ValueData *dst);
+
+    LIBSCRATCHCPP_EXPORT bool value_equals(const ValueData *v1, const ValueData *v2);
+    LIBSCRATCHCPP_EXPORT bool value_greater(const ValueData *v1, const ValueData *v2);
+    LIBSCRATCHCPP_EXPORT bool value_lower(const ValueData *v1, const ValueData *v2);
+}
+
+} // namespace libscratchcpp
diff --git a/include/scratchcpp/valuedata.h b/include/scratchcpp/valuedata.h
new file mode 100644
index 00000000..58c863cf
--- /dev/null
+++ b/include/scratchcpp/valuedata.h
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+#include "global.h"
+
+namespace libscratchcpp
+{
+
+enum class LIBSCRATCHCPP_EXPORT SpecialValue
+{
+    Infinity,
+    NegativeInfinity,
+    NaN
+};
+
+enum class LIBSCRATCHCPP_EXPORT ValueType
+{
+    Integer = 0,
+    Double = 1,
+    Bool = 2,
+    String = 3,
+    Infinity = -1,
+    NegativeInfinity = -2,
+    NaN = -3
+};
+
+extern "C"
+{
+    /*! \brief The ValueData struct holds the data of Value. It's used in compiled Scratch code for better performance. */
+    struct LIBSCRATCHCPP_EXPORT ValueData
+    {
+            union
+            {
+                    long intValue;
+                    double doubleValue;
+                    bool boolValue;
+                    char *stringValue;
+            };
+
+            ValueType type;
+            size_t stringSize; // allocated size, not length
+    };
+}
+
+} // namespace libscratchcpp
diff --git a/include/scratchcpp/veque.h b/include/scratchcpp/veque.h
new file mode 100644
index 00000000..f75877c7
--- /dev/null
+++ b/include/scratchcpp/veque.h
@@ -0,0 +1,1473 @@
+/*
+ * veque.hpp
+ *
+ * Efficient generic C++ container combining useful features of std::vector and std::deque
+ *
+ * Copyright (C) 2019 Drew Dormann
+ *
+ */
+
+#ifndef VEQUE_HEADER_GUARD
+#define VEQUE_HEADER_GUARD
+
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <ratio>
+#include <string>
+#include <type_traits>
+#include <stdexcept>
+#include <utility>
+
+namespace veque
+{
+    // Very fast resizing behavior
+    struct fast_resize_traits
+    {
+        // Relative to size(), amount of unused space to reserve when reallocating
+        using allocation_before_front = std::ratio<1>;
+        using allocation_after_back = std::ratio<1>;
+
+        // If true, arbitrary insert and erase operations are twice the speed of
+        // std::vector, but those operations invalidate all iterators
+        static constexpr auto resize_from_closest_side = true;
+    };
+
+    // Match std::vector iterator invalidation rules
+    struct vector_compatible_resize_traits
+    {
+        // Relative to size(), amount of unused space to reserve when reallocating
+        using allocation_before_front = std::ratio<1>;
+        using allocation_after_back = std::ratio<1>;
+
+        // If false, veque is a 100% compatible drop-in replacement for
+        // std::vector including iterator invalidation rules
+        static constexpr auto resize_from_closest_side = false;
+    };
+
+    // Resizing behavior resembling std::vector.  Also ideal for queue-like push_back/pop_front behavior.
+    struct std_vector_traits
+    {
+        // Reserve storage only at back, like std::vector
+        using allocation_before_front = std::ratio<0>;
+        using allocation_after_back = std::ratio<1>;
+
+        // Same iterator invalidation rules as std::vector
+        static constexpr auto resize_from_closest_side = false;
+    };
+
+    // Never reallocate more storage than is needed
+    struct no_reserve_traits
+    {
+        // Any operation requiring a greater size reserves only that size
+        using allocation_before_front = std::ratio<0>;
+        using allocation_after_back = std::ratio<0>;
+
+        // Same iterator invalidation rules as std::vector
+        static constexpr auto resize_from_closest_side = false;
+    };
+
+    template< typename T, typename ResizeTraits = fast_resize_traits, typename Allocator = std::allocator<T> >
+    class veque
+    {
+    public:
+        
+        // Types
+        using allocator_type = Allocator;
+        using alloc_traits = std::allocator_traits<allocator_type>;
+        using value_type = T;
+        using reference = T &;
+        using const_reference = const T &;
+        using pointer = T *;
+        using const_pointer = const T *;
+        using iterator = T *;
+        using const_iterator = const T *;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        using difference_type = std::ptrdiff_t;
+        using size_type = std::size_t;
+        using ssize_type = std::ptrdiff_t;
+
+        // Common member functions
+        veque() noexcept ( noexcept(Allocator()) )
+            : veque( Allocator() )
+        {
+        }
+
+        explicit veque( const Allocator& alloc ) noexcept
+            : _data { 0, alloc }
+        {
+        }
+
+        explicit veque( size_type n, const Allocator& alloc = Allocator() )
+            : veque( _allocate_uninitialized_tag{}, n, alloc )
+        {
+            _value_construct_range( begin(), end() );
+        }
+
+        veque( size_type n, const T &value, const Allocator& alloc = Allocator() )
+            : veque( _allocate_uninitialized_tag{}, n, alloc )
+        {
+            _value_construct_range( begin(), end(), value );
+        }
+
+        template< typename InputIt, typename ItCat = typename std::iterator_traits<InputIt>::iterator_category >
+        veque( InputIt b,  InputIt e, const Allocator& alloc = Allocator() )
+            : veque( b, e, alloc, ItCat{} )
+        {
+        }
+
+        veque( std::initializer_list<T> lst, const Allocator& alloc = Allocator() )
+            : veque( _allocate_uninitialized_tag{}, lst.size(), alloc )
+        {
+            _copy_construct_range( lst.begin(), lst.end(), begin() );
+        }
+
+        veque( const veque & other )
+            : veque( _allocate_uninitialized_tag{}, other.size(), alloc_traits::select_on_container_copy_construction( other._allocator() ) )
+        {
+            _copy_construct_range( other.begin(), other.end(), begin() );
+        }
+
+        template< typename OtherResizeTraits >
+        veque( const veque<T,OtherResizeTraits,Allocator> & other )
+            : veque( _allocate_uninitialized_tag{}, other.size(), alloc_traits::select_on_container_copy_construction( other._allocator() ) )
+        {
+            _copy_construct_range( other.begin(), other.end(), begin() );
+        }
+
+        template< typename OtherResizeTraits >
+        veque( const veque<T,OtherResizeTraits,Allocator> & other, const Allocator & alloc )
+            : veque( _allocate_uninitialized_tag{}, other.size(), alloc )
+        {
+            _copy_construct_range( other.begin(), other.end(), begin() );
+        }
+
+        veque( veque && other ) noexcept
+        {
+            _swap_with_allocator( std::move(other) );
+        }
+
+        template< typename OtherResizeTraits >
+        veque( veque<T,OtherResizeTraits,Allocator> && other ) noexcept
+        {
+            _swap_with_allocator( std::move(other) );
+        }
+
+        template< typename OtherResizeTraits >
+        veque( veque<T,OtherResizeTraits,Allocator> && other, const Allocator & alloc ) noexcept
+            : veque( alloc )
+        {
+            if constexpr ( !alloc_traits::is_always_equal::value )
+            {
+                if ( alloc != other._allocator() )
+                {
+                    // Incompatible allocators.  Allocate new storage.
+                    auto replacement = veque( _allocate_uninitialized_tag{}, other.size(), alloc );
+                    _nothrow_move_construct_range( other.begin(), other.end(), replacement.begin() );
+                    _swap_without_allocator( std::move(replacement) );
+                    return;
+                }
+            }
+            _swap_without_allocator( std::move(other) );
+        }
+
+        ~veque()
+        {
+            _destroy( begin(), end() );
+        }
+
+        veque & operator=( const veque & other )
+        {
+            return _copy_assignment( other );
+        }
+
+        template< typename OtherResizeTraits >
+        veque & operator=( const veque<T,OtherResizeTraits,Allocator> & other )
+        {
+            return _copy_assignment( other );
+        }
+
+        veque & operator=( veque && other ) noexcept(
+            noexcept(alloc_traits::propagate_on_container_move_assignment::value
+            || alloc_traits::is_always_equal::value) )
+        {
+            return _move_assignment( std::move(other) );
+        }
+
+        template< typename OtherResizeTraits >
+        veque & operator=( veque<T,OtherResizeTraits,Allocator> && other ) noexcept(
+            noexcept(alloc_traits::propagate_on_container_move_assignment::value
+            || alloc_traits::is_always_equal::value) )
+        {
+            return _move_assignment( std::move(other) );
+        }
+
+        veque & operator=( std::initializer_list<T> lst )
+        {
+            _assign( lst.begin(), lst.end() );
+            return *this;
+        }
+
+        void assign( size_type count, const T &value )
+        {
+            if ( count > capacity_full() )
+            {
+                _swap_without_allocator( veque( count, value, _allocator() ) );
+            }
+            else
+            {
+                _reassign_existing_storage( count, value );
+            }
+        }
+
+        template< typename InputIt, typename ItCat = typename std::iterator_traits<InputIt>::iterator_category >
+        void assign( InputIt b, InputIt e )
+        {
+            _assign( b, e, ItCat{} );
+        }
+
+        void assign( std::initializer_list<T> lst )
+        {
+            _assign( lst.begin(), lst.end() );
+        }
+
+        allocator_type get_allocator() const
+        {
+            return _allocator();
+        }
+
+        // Element access
+        reference at( size_type idx )
+        {
+            if ( idx >= size() )
+            {
+                throw std::out_of_range("veque<T,ResizeTraits,Alloc>::at(" + std::to_string(idx) + ") out of range");
+            }
+            return (*this)[idx];
+        }
+
+        const_reference at( size_type idx ) const
+        {
+            if ( idx >= size() )
+            {
+                throw std::out_of_range("veque<T,ResizeTraits,Alloc>::at(" + std::to_string(idx) + ") out of range");
+            }
+            return (*this)[idx];
+        }
+
+        reference operator[]( size_type idx )
+        {
+            return *(begin() + idx);
+        }
+
+        const_reference operator[]( size_type idx ) const
+        {
+            return *(begin() + idx);
+        }
+
+        reference front()
+        {
+            return (*this)[0];
+        }
+
+        const_reference front() const
+        {
+            return (*this)[0];
+        }
+
+        reference back()
+        {
+            return (*this)[size() - 1];
+        }
+
+        const_reference back() const
+        {
+            return (*this)[size() - 1];
+        }
+
+        T * data() noexcept
+        {
+            return begin();
+        }
+
+        const T * data() const noexcept
+        {
+            return begin();
+        }
+
+        // Iterators
+        const_iterator cbegin() const noexcept
+        {
+            return _storage_begin() + _offset;
+        }
+
+        iterator begin() noexcept
+        {
+            return _storage_begin() + _offset;
+        }
+
+        const_iterator begin() const noexcept
+        {
+            return cbegin();
+        }
+
+        const_iterator cend() const noexcept
+        {
+            return _storage_begin() + _offset + size();
+        }
+
+        iterator end() noexcept
+        {
+            return _storage_begin() + _offset + size();
+        }
+
+        const_iterator end() const noexcept
+        {
+            return cend();
+        }
+
+        const_reverse_iterator crbegin() const noexcept
+        {
+            return const_reverse_iterator(cend());
+        }
+
+        reverse_iterator rbegin() noexcept
+        {
+            return reverse_iterator(end());
+        }
+
+        const_reverse_iterator rbegin() const noexcept
+        {
+            return crbegin();
+        }
+
+        const_reverse_iterator crend() const noexcept
+        {
+            return const_reverse_iterator(cbegin());
+        }
+
+        reverse_iterator rend() noexcept
+        {
+            return reverse_iterator(begin());
+        }
+
+        const_reverse_iterator rend() const noexcept
+        {
+            return crend();
+        }
+
+        // Capacity
+        [[nodiscard]] bool empty() const noexcept
+        {
+            return size() == 0;
+        }
+
+        size_type size() const noexcept
+        {
+            return _size;
+        }
+
+        ssize_type ssize() const noexcept
+        {
+            return _size;
+        }
+
+        size_type max_size() const noexcept
+        {
+            constexpr auto compile_time_limit = std::min(
+                // The ssize type's ceiling
+                std::numeric_limits<ssize_type>::max() / sizeof(T),
+                // Ceiling imposed by std::ratio math
+                std::numeric_limits<size_type>::max() / _full_realloc::num
+            );
+
+            // The allocator's ceiling
+            auto runtime_limit = alloc_traits::max_size(_allocator() );
+
+            return std::min( compile_time_limit, runtime_limit );
+        }
+
+        // Reserve front and back capacity, in one operation.
+        void reserve( size_type front, size_type back )
+        {
+            if ( front > capacity_front() || back > capacity_back() )
+            {
+                auto allocated_before_begin = std::max( capacity_front(), front ) - size();
+                auto allocated_after_begin = std::max( capacity_back(), back );
+                auto new_full_capacity = allocated_before_begin + allocated_after_begin;
+                
+                if ( new_full_capacity > max_size() )
+                {
+                    throw std::length_error("veque<T,ResizeTraits,Alloc>::reserve(" + std::to_string(front) + ", " + std::to_string(back) + ") exceeds max_size()");
+                }
+                _reallocate( new_full_capacity, allocated_before_begin );
+            }
+        }
+
+        void reserve_front( size_type count )
+        {
+            reserve( count, 0 );
+        }
+
+        void reserve_back( size_type count )
+        {
+            reserve( 0, count );
+        }
+
+        void reserve( size_type count )
+        {
+            reserve( count, count );
+        }
+
+        // Returns current size + unused allocated storage before front()
+        size_type capacity_front() const noexcept
+        {
+            return _offset + size();
+        }
+
+        // Returns current size + unused allocated storage after back()
+        size_type capacity_back() const noexcept
+        {
+            return capacity_full() - _offset;
+        }
+
+        // Returns current size + all unused allocated storage
+        size_type capacity_full() const noexcept
+        {
+            return _data._allocated;
+        }
+
+        // To achieve interface parity with std::vector, capacity() returns capacity_back();
+        size_type capacity() const noexcept
+        {
+            return capacity_back();
+        }
+
+        void shrink_to_fit()
+        {
+            if ( size() < capacity_full() )
+            {
+                _reallocate( size(), 0 );
+            }
+        }
+
+        // Modifiers
+        void clear() noexcept
+        {
+            _destroy( begin(), end() );
+            _size = 0;
+            _offset = 0;
+            if constexpr ( std::ratio_greater_v<_unused_realloc, std::ratio<0>> )
+            {
+                using unused_front_ratio = std::ratio_divide<_front_realloc,_unused_realloc>;
+                _offset = capacity_full() * unused_front_ratio::num / unused_front_ratio::den;
+            }
+        }
+
+        iterator insert( const_iterator it, const T & value )
+        {
+            return emplace( it, value );
+        }
+
+        iterator insert( const_iterator it, T && value )
+        {
+            return emplace( it, std::move(value) );
+        }
+
+        iterator insert( const_iterator it, size_type count, const T & value )
+        {
+            auto res = _insert_storage( it, count );
+            _value_construct_range( res, res + count, value );
+            return res;
+        }
+
+        template< typename InputIt, typename ItCat = typename std::iterator_traits<InputIt>::iterator_category >
+        iterator insert( const_iterator it, InputIt b, InputIt e )
+        {
+            return _insert( it, b, e, ItCat{} );
+        }
+
+        iterator insert( const_iterator it, std::initializer_list<T> lst )
+        {
+            return insert( it, lst.begin(), lst.end() );
+        }
+
+        template< typename ...Args >
+        iterator emplace( const_iterator it, Args && ... args )
+        {
+            auto res = _insert_storage( it, 1 );
+            alloc_traits::construct( _allocator(), res, std::forward<Args>(args)... );
+            return res;
+        }
+
+        iterator erase( const_iterator it )
+        {
+            return erase( it, std::next(it) );
+        }
+
+        iterator erase( const_iterator b, const_iterator e )
+        {
+            auto count = std::distance( b, e );
+            if constexpr ( _resize_from_closest_side )
+            {
+                auto elements_before = std::distance( cbegin(), b );
+                auto elements_after = std::distance( e, cend( ) );
+                if (  elements_before < elements_after )
+                {
+                    _shift_back( begin(), b, count );
+                    _move_begin( count );
+                    return _mutable_iterator(e);
+                }
+            }
+            _shift_front( e, end(), count );
+            _move_end(-count);
+            return _mutable_iterator(b);
+        }
+
+        void push_back( const T & value )
+        {
+            emplace_back( value );
+        }
+
+        void push_back( T && value )
+        {
+            emplace_back( std::move(value) );
+        }
+
+        template< typename ... Args>
+        reference emplace_back( Args && ...args )
+        {
+            if ( size() == capacity_back() )
+            {
+                _reallocate_space_at_back( size() + 1 );
+            }
+            alloc_traits::construct( _allocator(), end(), std::forward<Args>(args)... );
+            _move_end( 1 );
+            return back();
+        }
+
+        void push_front( const T & value )
+        {
+            emplace_front( value );
+        }
+
+        void push_front( T && value )
+        {
+            emplace_front( std::move(value) );
+        }
+
+        template< typename ... Args>
+        reference emplace_front( Args && ...args )
+        {
+            if ( size() == capacity_front() )
+            {
+                _reallocate_space_at_front( size() + 1 );
+            }
+            alloc_traits::construct( _allocator(), begin()-1, std::forward<Args>(args)... );
+            _move_begin( -1 );
+            return front();
+        }
+
+        void pop_back()
+        {
+            alloc_traits::destroy( _allocator(), &back() );
+            _move_end( -1 );
+        }
+
+        // Move-savvy pop back with strong exception guarantee
+        T pop_back_element()
+        {
+            auto res( _nothrow_construct_move(back()) );
+            pop_back();
+            return res;
+        }
+
+        void pop_front()
+        {
+            alloc_traits::destroy( _allocator(), &front() );
+            _move_begin( 1 );
+        }
+
+        // Move-savvy pop front with strong exception guarantee
+        T pop_front_element()
+        {
+            auto res( _nothrow_construct_move(front()) );
+            pop_front();
+            return res;
+        }
+
+        // Resizes the veque, by adding or removing from the front. 
+        void resize_front( size_type count )
+        {
+            _resize_front( count );
+        }
+
+        void resize_front( size_type count, const T & value )
+        {
+            _resize_front( count, value );
+        }
+
+        // Resizes the veque, by adding or removing from the back.
+        void resize_back( size_type count )
+        {
+            _resize_back( count );
+        }
+
+        void resize_back( size_type count, const T & value )
+        {
+            _resize_back( count, value );
+        }
+
+        // To achieve interface parity with std::vector, resize() performs resize_back();
+        void resize( size_type count )
+        {
+            _resize_back( count );
+        }
+
+        void resize( size_type count, const T & value )
+        {
+            _resize_back( count, value );
+        }
+
+        template< typename OtherResizeTraits >
+        void swap( veque<T,OtherResizeTraits,Allocator> & other ) noexcept(
+            noexcept(alloc_traits::propagate_on_container_swap::value
+            || alloc_traits::is_always_equal::value))
+        {
+            if constexpr ( alloc_traits::propagate_on_container_swap::value )
+            {
+                _swap_with_allocator( std::move(other) );
+            }
+            else
+            {
+                if ( _allocator() == other._allocator() )
+                {
+                    _swap_without_allocator( std::move(other) );
+                }
+                else
+                {
+                    // std::vector would declare this UB.  Allocate compatible storage and make it work.
+                    auto new_this = veque( _allocate_uninitialized_tag{}, other.size(), _allocator() );
+                    _nothrow_move_construct_range( other.begin(), other.end(), new_this.begin() );
+
+                    auto new_other = veque( _allocate_uninitialized_tag{}, size(), other._allocator() );
+                    _nothrow_move_construct_range( begin(), end(), new_other.begin() );
+
+                    _swap_without_allocator( std::move(new_this) );
+                    other._swap_without_allocator( std::move(new_other) );
+                }
+            }
+        }
+
+    private:
+
+        using _front_realloc = typename ResizeTraits::allocation_before_front::type;
+        using _back_realloc = typename ResizeTraits::allocation_after_back::type;
+        using _unused_realloc = std::ratio_add< _front_realloc, _back_realloc >;
+        using _full_realloc = std::ratio_add< std::ratio<1>, _unused_realloc >;
+
+        static constexpr auto _resize_from_closest_side = ResizeTraits::resize_from_closest_side;
+
+        static_assert( _front_realloc::den > 0  );
+        static_assert( _back_realloc::den > 0  );
+        static_assert( std::ratio_greater_equal_v<_front_realloc,std::ratio<0>>, "Reserving negative space is not well-defined" );
+        static_assert( std::ratio_greater_equal_v<_back_realloc,std::ratio<0>>, "Reserving negative space is not well-defined" );
+        static_assert( std::ratio_greater_equal_v<_unused_realloc,std::ratio<0>>, "Reserving negative space is not well-defined" );
+
+        // Confirmation that allocator_traits will only directly call placement new(ptr)T()
+        static constexpr auto _calls_default_constructor_directly = 
+            std::is_same_v<allocator_type,std::allocator<T>>;
+        // Confirmation that allocator_traits will only directly call placement new(ptr)T(const T&)
+        static constexpr auto _calls_copy_constructor_directly = 
+            std::is_same_v<allocator_type,std::allocator<T>>;
+        // Confirmation that allocator_traits will only directly call ~T()
+        static constexpr auto _calls_destructor_directly =
+            std::is_same_v<allocator_type,std::allocator<T>>;
+
+        size_type _size = 0;    // Number of elements in use
+        size_type _offset = 0;  // Number of uninitialized elements before begin()
+
+        // Deriving from allocator to leverage empty base optimization
+        struct Data : Allocator
+        {
+            T *_storage = nullptr;
+            size_type _allocated = 0;
+
+            Data() = default;
+            Data( size_type size, const Allocator & alloc )
+                : Allocator{alloc}
+                , _storage{size ? std::allocator_traits<Allocator>::allocate( allocator(), size ) : nullptr}
+                , _allocated{size}
+            {
+            }
+            Data( const Data& ) = delete;
+            Data( Data && other )
+            {
+                *this = std::move(other);
+            }
+            ~Data()
+            {
+                if ( _storage )
+                {
+                    std::allocator_traits<Allocator>::deallocate( allocator(), _storage, _allocated );
+                }
+            }
+            Data& operator=( const Data & ) = delete;
+            Data& operator=( Data && other )
+            {
+                using std::swap;
+                if constexpr( ! std::is_empty_v<Allocator> )
+                {
+                    swap(allocator(), other.allocator());
+                }
+                swap(_allocated,  other._allocated);
+                swap(_storage,    other._storage);
+                return *this;
+            }
+            Allocator& allocator() { return *this; }
+            const Allocator& allocator() const { return *this; }
+        } _data;
+
+        template< typename InputIt >
+        veque( InputIt b, InputIt e, const Allocator & alloc, std::input_iterator_tag )
+            : veque{alloc}
+        {
+            for ( ; b != e; ++b )
+            {
+                push_back( *b );
+            }
+        }
+
+        template< typename InputIt >
+        veque( InputIt b, InputIt e, const Allocator & alloc, std::forward_iterator_tag )
+            : veque( _allocate_uninitialized_tag{}, std::distance( b, e ), alloc )
+        {
+            _copy_construct_range( b, e, begin() );
+        }
+
+        // Private tag to indicate initial allocation
+        struct _allocate_uninitialized_tag {};
+        // Private tag to indicate resizing allocation
+        struct _reallocate_uninitialized_tag {};
+
+        // Create an uninitialized empty veque, with specified storage params
+        veque( _allocate_uninitialized_tag, size_type size, size_type allocated, size_type offset, const Allocator & alloc )
+            : _size{ size }
+            , _offset{ offset }
+            , _data { allocated, alloc }
+        {
+        }
+
+        // Create an uninitialized empty veque, with storage for expected size
+        veque( _allocate_uninitialized_tag, size_type size, const Allocator & alloc )
+            : veque( _allocate_uninitialized_tag{}, size, size, 0, alloc )
+        {
+        }
+
+        // Create an uninitialized empty veque, with storage for expected reallocated size
+        veque( _reallocate_uninitialized_tag, size_type size, const Allocator & alloc )
+            : veque( _allocate_uninitialized_tag{}, size, _calc_reallocation(size), _calc_offset(size), alloc )
+        {
+        }
+
+        static constexpr size_type _calc_reallocation( size_type size )
+        {
+            return size * _full_realloc::num / _full_realloc::den;
+        }
+
+        static constexpr size_type _calc_offset( size_type size )
+        {
+            return size * _front_realloc::num / _front_realloc::den;
+        }
+
+        // Acquire Allocator
+        Allocator& _allocator() noexcept
+        {
+            return _data.allocator();
+        }
+
+        const Allocator& _allocator() const noexcept
+        {
+            return _data.allocator();
+        }
+
+        // Destroy elements in range
+        void _destroy( const_iterator b, const_iterator e )
+        {
+            if constexpr ( std::is_trivially_destructible_v<T> && _calls_destructor_directly )
+            {
+                (void)b; (void)e; // Unused
+            }
+            else
+            {
+                auto start = _mutable_iterator(b);
+                for ( auto i = start; i != e; ++i )
+                {
+                    alloc_traits::destroy( _allocator(), i );
+                }
+            }
+        }
+
+        template< typename OtherResizeTraits >
+        veque & _copy_assignment( const veque<T,OtherResizeTraits,Allocator> & other )
+        {
+            if constexpr ( alloc_traits::propagate_on_container_copy_assignment::value )
+            {
+                if constexpr ( !alloc_traits::is_always_equal::value )
+                {
+                    if ( other._allocator() != _allocator() || other.size() > capacity_full() )
+                    {
+                        _swap_with_allocator( veque( other, other._allocator() ) );
+                        return *this;
+                    }
+                }
+            }
+            if ( other.size() > capacity_full() )
+            {
+                _swap_without_allocator( veque( other, _allocator() ) );
+            }
+            else
+            {
+                _reassign_existing_storage( other.begin(), other.end() );
+            }
+            return *this;
+        }
+
+        template< typename OtherResizeTraits >
+        veque & _move_assignment( veque<T,OtherResizeTraits,Allocator> && other ) noexcept(
+            noexcept(alloc_traits::propagate_on_container_move_assignment::value
+            || alloc_traits::is_always_equal::value) )
+        {
+            if constexpr ( !alloc_traits::is_always_equal::value )
+            {
+                if ( _allocator() != other._allocator() )
+                {
+                    if constexpr ( alloc_traits::propagate_on_container_move_assignment::value )
+                    {
+                        _swap_with_allocator( std::move(other) );
+                    }
+                    else
+                    {
+                        if ( other.size() > capacity_full() )
+                        {
+                            _swap_without_allocator( veque( std::move(other), _allocator() ) );
+                        }
+                        else
+                        {
+                            _reassign_existing_storage( std::move_iterator(other.begin()), std::move_iterator(other.end()) );
+                        }
+                    }
+                    return *this;
+                }
+            }
+            _swap_without_allocator( std::move(other) );
+            return *this;
+        }
+
+        // Construct elements in range
+        template< typename ...Args >
+        void _value_construct_range( const_iterator b, const_iterator e, const Args & ...args )
+        {
+            static_assert( sizeof...(args) <= 1, "This is for default- or copy-constructing" );
+
+            if constexpr ( std::is_trivially_copy_constructible_v<T> && _calls_default_constructor_directly )
+            {
+                if constexpr ( sizeof...(args) == 0 )
+                {
+                    std::memset( _mutable_iterator(b), 0, std::distance( b, e ) * sizeof(T) );
+                }
+                else
+                {
+                    std::fill( _mutable_iterator(b), _mutable_iterator(e), args...);
+                }
+            }
+            else
+            {
+                for ( auto dest = _mutable_iterator(b); dest != e; ++dest )
+                {
+                    alloc_traits::construct( _allocator(), dest, args... );
+                }
+            }
+        }
+
+        template< typename It >
+        void _copy_construct_range( It b, It e, const_iterator dest )
+        {
+            static_assert( std::is_convertible_v<typename std::iterator_traits<It>::iterator_category,std::forward_iterator_tag> );
+            if constexpr ( std::is_trivially_copy_constructible_v<T> && _calls_copy_constructor_directly )
+            {
+                std::memcpy( _mutable_iterator(dest), b, std::distance( b, e ) * sizeof(T) );
+            }
+            else
+            {
+                for ( ; b != e; ++dest, ++b )
+                {
+                    alloc_traits::construct( _allocator(), dest, *b );
+                }
+            }
+        }
+        
+        template< typename It >
+        void _assign( It b, It e )
+        {
+            static_assert( std::is_convertible_v<typename std::iterator_traits<It>::iterator_category,std::forward_iterator_tag> );
+            if ( std::distance( b, e ) > static_cast<difference_type>(capacity_full()) )
+            {
+                _swap_without_allocator( veque( b, e, _allocator() ) );
+            }
+            else
+            {
+                _reassign_existing_storage( b, e );
+            }
+        }
+
+        template< typename It >
+        void _assign( It b, It e, std::forward_iterator_tag )
+        {
+            _assign( b, e );
+        }
+
+        template< typename It >
+        void _assign( It b, It e, std::input_iterator_tag )
+        {
+            // Input Iterators require a single-pass solution
+            clear();
+            for ( ; b != e; ++b )
+            {
+                push_back( *b );
+            }
+        }
+
+        template< typename It >
+        iterator _insert( const_iterator it, It b, It e )
+        {
+            static_assert( std::is_convertible_v<typename std::iterator_traits<It>::iterator_category,std::forward_iterator_tag> );
+            auto res = _insert_storage( it, std::distance( b, e ) );
+            _copy_construct_range( b, e, res );
+            return res;
+        }
+
+        template< typename It >
+        iterator _insert( const_iterator it, It b, It e, std::forward_iterator_tag )
+        {
+            return _insert( it, b, e );
+        }
+
+        template< typename It >
+        iterator _insert( const_iterator it, It b, It e, std::input_iterator_tag )
+        {
+            // Input Iterators require a single-pass solution
+            auto allocated = veque( b, e );
+            _insert( it, allocated.begin(), allocated.end() );
+        }
+
+        template< typename OtherResizeTraits >
+        void _swap_with_allocator( veque<T,OtherResizeTraits,Allocator> && other ) noexcept
+        {
+            // Swap everything
+            std::swap( _size,      other._size );
+            std::swap( _offset,    other._offset );
+            std::swap( _data,      other._data );
+        }
+
+        template< typename OtherResizeTraits >
+        void _swap_without_allocator( veque<T,OtherResizeTraits,Allocator> && other ) noexcept
+        {
+            // Don't swap _data.allocator().
+            std::swap( _size,            other._size );
+            std::swap( _offset,          other._offset );
+            std::swap( _data._allocated, other._data._allocated);
+            std::swap( _data._storage,   other._data._storage);
+        }
+
+        template< typename ...Args >
+        void _resize_front( size_type count, const Args & ...args )
+        {
+            difference_type delta = count - size();
+            if ( delta > 0 )
+            {
+                if ( count > capacity_front() )
+                {
+                    _reallocate_space_at_front( count );
+                }
+                _value_construct_range( begin() - delta, begin(), args... );
+            }
+            else
+            {
+                _destroy( begin(), begin() - delta );
+            }
+            _move_begin( -delta );
+        }
+
+        template< typename ...Args >
+        void _resize_back( size_type count, const Args & ...args )
+        {
+            difference_type delta = count - size();
+            if ( delta > 0 )
+            {
+                if ( count > capacity_back() )
+                {
+                    _reallocate_space_at_back( count );
+                }
+                _value_construct_range( end(), end() + delta, args... );
+            }
+            else
+            {
+                _destroy( end() + delta, end() );
+            }
+            _move_end( delta );
+        }
+
+        // Move veque to new storage, with specified capacity...
+        // ...and yet-unused space at back of this storage
+        void _reallocate_space_at_back( size_type count )
+        {
+            auto storage_needed = _calc_reallocation(count);
+            auto current_capacity = capacity_full();
+            auto new_offset = _calc_offset(count);
+            if ( storage_needed <= current_capacity )
+            {
+                // Shift elements toward front
+                auto distance = _offset - new_offset;
+                _shift_front( begin(), end(), distance  );
+                _move_begin(-distance);
+                _move_end(-distance);
+            }
+            else
+            {
+                _reallocate( storage_needed, new_offset );
+            }
+        }
+        
+        // ...and yet-unused space at front of this storage
+        void _reallocate_space_at_front( size_type count )
+        {
+            auto storage_needed = _calc_reallocation(count);
+            auto current_capacity = capacity_full();
+            auto new_offset = count - size() + _calc_offset(count);
+            if ( storage_needed <= current_capacity )
+            {
+                // Shift elements toward back
+                auto distance = new_offset - _offset;
+                _shift_back( begin(), end(), distance );
+                _move_begin(distance);
+                _move_end(distance);
+            }
+            else
+            {
+                _reallocate( storage_needed, new_offset );
+            }
+        }
+        
+        // Move veque to new storage, with specified capacity
+        void _reallocate( size_type allocated, size_type offset )
+        {
+            auto replacement = veque( _allocate_uninitialized_tag{}, size(), allocated, offset, _allocator() );
+            _nothrow_move_construct_range( begin(), end(), replacement.begin() );
+            _swap_without_allocator( std::move(replacement) );
+        }
+
+        // Insert empty space, choosing the most efficient way to shift existing elements
+        iterator _insert_storage( const_iterator it, size_type count )
+        {
+            auto required_size = size() + count;
+            auto can_shift_back = capacity_back() >= required_size;
+            if constexpr ( std::ratio_greater_v<_front_realloc,std::ratio<0>> )
+            {
+                if ( can_shift_back && it == begin() )
+                {
+                    // Don't favor shifting entire contents back
+                    // if realloc will create space
+                    can_shift_back = false;
+                }
+            }
+
+            if constexpr ( _resize_from_closest_side )
+            {
+                auto can_shift_front = capacity_front() >= required_size;
+                if constexpr ( std::ratio_greater_v<_back_realloc,std::ratio<0>> )
+                {
+                    if ( can_shift_front && it == end() )
+                    {
+                        // Don't favor shifting entire contents front
+                        // if realloc will create space
+                        can_shift_front = false;
+                    }
+                }
+
+                if ( can_shift_back && can_shift_front)
+                {
+                    // Capacity allows shifting in either direction.
+                    // Remove the choice with the greater operation count.
+                    auto index = std::distance( cbegin(), it );
+                    if ( index <= ssize() / 2 )
+                    {
+                        can_shift_back = false;
+                    }
+                    else
+                    {
+                        can_shift_front = false;
+                    }
+                }
+
+                if ( can_shift_front )
+                {
+                    _shift_front( begin(), it, count );
+                    _move_begin( -count );
+                    return _mutable_iterator(it) - count;
+                }
+            }
+            if ( can_shift_back )
+            {
+                _shift_back( it, end(), count );
+                _move_end( count );
+                return _mutable_iterator(it);
+            }
+
+            // Insufficient capacity.  Allocate new storage.
+            auto replacement = veque( _reallocate_uninitialized_tag{}, required_size, _allocator() );
+            auto index = std::distance( cbegin(), it );
+            auto insertion_point = begin() + index;
+
+            _nothrow_move_construct_range( begin(), insertion_point, replacement.begin() );
+            _nothrow_move_construct_range( insertion_point, end(), replacement.begin() + index + count );
+            _swap_with_allocator( std::move(replacement) );
+            return begin() + index;
+        }
+
+        // Moves a valid subrange in the front direction.
+        // Veque will grow, if range moves past begin().
+        // Veque will shrink if range includes end().
+        // Returns iterator to beginning of destructed gap
+        void _shift_front( const_iterator b, const_iterator e, size_type count )
+        {
+            if ( e == begin() )
+            {
+                return;
+            }
+            auto element_count = std::distance( b, e );
+            auto start = _mutable_iterator(b);
+            if ( element_count > 0 )
+            {
+                auto dest = start - count;
+                if constexpr ( std::is_trivially_copyable_v<T> && std::is_trivially_copy_constructible_v<T> && _calls_copy_constructor_directly )
+                {
+                    std::memmove( dest, start, element_count * sizeof(T) );
+                }
+                else
+                {
+                    auto src = start;
+                    auto dest_construct_end = std::min( begin(), _mutable_iterator(e) - count );
+                    for ( ; dest < dest_construct_end; ++src, ++dest )
+                    {
+                        _nothrow_move_construct( dest, src );
+                    }
+                    for ( ; src != e; ++src, ++dest )
+                    {
+                        _nothrow_move_assign( dest, src );
+                    }
+                }
+            }
+            _destroy( std::max( cbegin(), e - count ), e );
+        }
+
+        // Moves a range towards the back.  Veque will grow, if needed.  Vacated elements are destructed.
+        // Moves a valid subrange in the back direction.
+        // Veque will grow, if range moves past end().
+        // Veque will shrink if range includes begin().
+        // Returns iterator to beginning of destructed gap
+        void _shift_back( const_iterator b, const_iterator e, size_type count )
+        {
+            auto start = _mutable_iterator(b); 
+            if ( b == end() )
+            {
+                return;
+            }
+            auto element_count = std::distance( b, e );
+            if ( element_count > 0 )
+            {
+                if constexpr ( std::is_trivially_copyable_v<T> && std::is_trivially_copy_constructible_v<T> && _calls_copy_constructor_directly )
+                {
+                    std::memmove( start + count, start, element_count * sizeof(T) );
+                }
+                else
+                {
+                    auto src = _mutable_iterator(e-1);
+                    auto dest = src + count;
+                    auto dest_construct_end = std::max( end()-1, dest - element_count );
+                    for ( ; dest > dest_construct_end; --src, --dest )
+                    {
+                        // Construct to destinations at or after end()
+                        _nothrow_move_construct( dest, src );
+                    }
+                    for ( ; src != b-1; --src, --dest )
+                    {
+                        // Assign to destinations before before end()
+                        _nothrow_move_assign( dest, src );
+                    }
+                }
+            }
+            _destroy( b, std::min( cend(), b + count ) );
+        }
+
+        // Assigns a fitting range of new elements to currently held storage.
+        // Favors copying over constructing firstly, and positioning the new elements
+        // at the center of storage secondly
+        template< typename It >
+        void _reassign_existing_storage( It b, It e )
+        {
+            static_assert( std::is_convertible_v<typename std::iterator_traits<It>::iterator_category,std::forward_iterator_tag> );
+
+            auto count = std::distance( b, e );
+            auto size_delta = static_cast<difference_type>( count - size() );
+            // The "ideal" begin would put the new data in the center of storage
+            auto ideal_begin = _storage_begin() + (capacity_full() - count) / 2;
+
+            if ( size() == 0 )
+            {
+                // Existing veque is empty.  Construct at the ideal location
+                _copy_construct_range( b, e, ideal_begin );        
+            }
+            else if ( size_delta == 0 )
+            {
+                // Existing veque is the same size.  Avoid any construction by copy-assigning everything
+                std::copy( b, e, begin() );
+                return;
+            }
+            else if ( size_delta < 0 )
+            {
+                // New size is smaller.  Copy-assign everything, placing results as close to center as possible
+                ideal_begin = std::clamp( ideal_begin, begin(), end() - count );
+
+                _destroy( begin(), ideal_begin );
+                auto ideal_end = std::copy( b, e, ideal_begin );
+                _destroy( ideal_end, end() );
+            }
+            else
+            {
+                // New size is larger.  Copy-assign all existing elements, placing newly
+                // constructed elements so final store is as close to center as possible
+                ideal_begin = std::clamp( ideal_begin, end() - count, begin() );
+
+                auto src = b;
+                auto copy_src = src + std::distance( ideal_begin, begin() );
+                _copy_construct_range( src, copy_src, ideal_begin );
+                std::copy( copy_src, copy_src + ssize(), begin() );
+                _copy_construct_range( copy_src + ssize(), e, end() );
+            }
+            _move_begin( std::distance( begin(), ideal_begin ) );
+            _move_end( std::distance( end(), ideal_begin + count ) );
+        }
+
+        void _reassign_existing_storage( size_type count, const T & value )
+        {
+            auto size_delta = static_cast<difference_type>( count - size() );
+            auto ideal_begin = _storage_begin();
+            // The "ideal" begin would put the new data in the center of storage
+            if constexpr ( std::ratio_greater_v<_unused_realloc, std::ratio<0>> )
+            {
+                using ideal_begin_ratio = std::ratio_divide<_front_realloc, _unused_realloc >;
+                ideal_begin += (capacity_full() - count) * ideal_begin_ratio::num / ideal_begin_ratio::den;
+            }
+
+            if ( size() == 0 )
+            {
+                // Existing veque is empty.  Construct at the ideal location
+                _value_construct_range( ideal_begin, ideal_begin + count, value );
+            }
+            else if ( size_delta == 0 )
+            {
+                // Existing veque is the same size.  Avoid any construction by copy-assigning everything
+                std::fill( begin(), end(), value );
+                return;
+            }
+            else if ( size_delta < 0 )
+            {
+                // New size is smaller.  Copy-assign everything, placing results as close to center as possible
+                ideal_begin = std::clamp( ideal_begin, begin(), end() - count );
+
+                _destroy( begin(), ideal_begin );
+                std::fill( ideal_begin, ideal_begin + count, value );
+                _destroy( ideal_begin + count, end() );
+            }
+            else
+            {
+                // New size is larger.  Copy-assign all existing elements, placing newly
+                // constructed elements so final store is as close to center as possible
+                ideal_begin += _calc_offset(capacity_full() - count) / 2;
+                _value_construct_range( ideal_begin, begin(), value );
+                std::fill( begin(), end(), value );
+                _value_construct_range( end(), ideal_begin + count, value );
+            }
+            _move_begin( std::distance( begin(), ideal_begin ) );
+            _move_end( std::distance( end(), ideal_begin + count ) );
+        }
+
+        // Casts to T&& or T&, depending on whether move construction is noexcept
+        static decltype(auto) _nothrow_construct_move( T & t )
+        {
+            if constexpr ( std::is_nothrow_move_constructible_v<T> )
+            {
+                return std::move(t);
+            }
+            else
+            {
+                return t;
+            }
+        }
+
+        // Move-constructs if noexcept, copies otherwise
+        void _nothrow_move_construct( iterator dest, iterator src )
+        {
+            if constexpr ( std::is_trivially_copy_constructible_v<T> && _calls_copy_constructor_directly )
+            {
+                *dest = *src;
+            }
+            else
+            {
+                alloc_traits::construct( _allocator(), dest, _nothrow_construct_move(*src) );
+            }
+        }
+
+        void _nothrow_move_construct_range( iterator b, iterator e, iterator dest )
+        {
+            auto size = std::distance( b, e );
+            if ( size )
+            {
+                if constexpr ( std::is_trivially_copy_constructible_v<T> && _calls_copy_constructor_directly )
+                {
+                    std::memcpy( dest, b, size * sizeof(T) );
+                }
+                else
+                {
+                    for ( ; b != e; ++dest, ++b )
+                    {
+                        _nothrow_move_construct( dest, b );
+                    }
+                }
+            }
+        }
+
+        // Move-assigns if noexcept, copies otherwise
+        static void _nothrow_move_assign( iterator dest, iterator src )
+        {
+            if constexpr ( std::is_nothrow_move_assignable_v<T> )
+            {
+                *dest = std::move(*src);
+            }
+            else
+            {
+                *dest = *src;
+            }
+        }
+
+        static void _nothrow_move_assign_range( iterator b, iterator e, iterator src )
+        {
+            for ( auto dest = b; dest != e; ++dest, ++src )
+            {
+                _nothrow_move_assign( dest, src );
+            }
+        }
+
+        // Adjust begin(), end() iterators
+        void _move_begin( difference_type count ) noexcept
+        {
+            _size -= count;
+            _offset += count;
+        }
+
+        void _move_end( difference_type count ) noexcept
+        {
+            _size += count;
+        }
+
+        // Convert a local const_iterator to iterator
+        iterator _mutable_iterator( const_iterator i )
+        {
+            return begin() + std::distance( cbegin(), i );
+        }
+
+        // Retrieves beginning of storage, which may be before begin()
+        const_iterator _storage_begin() const noexcept
+        {
+            return _data._storage;
+        }
+
+        iterator _storage_begin() noexcept
+        {
+            return _data._storage;
+        }
+    };
+
+    template< typename T, typename LResizeTraits, typename LAlloc, typename RResizeTraits, typename RAlloc >
+    inline bool operator==( const veque<T,LResizeTraits,LAlloc> &lhs, const veque<T,RResizeTraits,RAlloc> &rhs )
+    {
+        return std::equal( lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
+    }
+
+    template< typename T, typename LResizeTraits, typename LAlloc, typename RResizeTraits, typename RAlloc >
+    inline bool operator!=( const veque<T,LResizeTraits,LAlloc> &lhs, const veque<T,RResizeTraits,RAlloc> &rhs )
+    {
+        return !( lhs == rhs );
+    }
+
+    template< typename T, typename LResizeTraits, typename LAlloc, typename RResizeTraits, typename RAlloc >
+    inline bool operator<( const veque<T,LResizeTraits,LAlloc> &lhs, const veque<T,RResizeTraits,RAlloc> &rhs )
+    {
+        return std::lexicographical_compare( lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
+    }
+
+    template< typename T, typename LResizeTraits, typename LAlloc, typename RResizeTraits, typename RAlloc >
+    inline bool operator<=( const veque<T,LResizeTraits,LAlloc> &lhs, const veque<T,RResizeTraits,RAlloc> &rhs )
+    {
+        return !( rhs < lhs );
+    }
+
+    template< typename T, typename LResizeTraits, typename LAlloc, typename RResizeTraits, typename RAlloc >
+    inline bool operator>( const veque<T,LResizeTraits,LAlloc> &lhs, const veque<T,RResizeTraits,RAlloc> &rhs )
+    {
+        return ( rhs < lhs );
+    }
+
+    template< typename T, typename LResizeTraits, typename LAlloc, typename RResizeTraits, typename RAlloc >
+    inline bool operator>=( const veque<T,LResizeTraits,LAlloc> &lhs, const veque<T,RResizeTraits,RAlloc> &rhs )
+    {
+        return !( lhs < rhs );
+    }
+
+    template< typename T, typename ResizeTraits, typename Alloc >
+    inline void swap( veque<T,ResizeTraits,Alloc> & lhs, veque<T,ResizeTraits,Alloc> & rhs ) noexcept(noexcept(lhs.swap(rhs)))
+    {
+        lhs.swap(rhs);
+    }
+
+    // Template deduction guide for iterator pair
+    template< typename InputIt,
+              typename Alloc = std::allocator<typename std::iterator_traits<InputIt>::value_type>>
+    veque(InputIt, InputIt, Alloc = Alloc())
+      -> veque<typename std::iterator_traits<InputIt>::value_type, fast_resize_traits, Alloc>;
+
+}
+
+namespace std
+{
+    template< typename T, typename ResizeTraits, typename Alloc >
+    struct hash<veque::veque<T,ResizeTraits,Alloc>>
+    {
+        size_t operator()( const veque::veque<T,ResizeTraits,Alloc> & v ) const
+        {
+            size_t hash = 0;
+            auto hasher = std::hash<T>();
+            for ( auto && val : v )
+            {
+                hash ^= hasher(val) + 0x9e3779b9 + (hash<<6) + (hash>>2);
+            }
+            return hash;
+        }
+    };
+}
+
+#endif
diff --git a/include/scratchcpp/virtualmachine.h b/include/scratchcpp/virtualmachine.h
index 58541495..e72aef4f 100644
--- a/include/scratchcpp/virtualmachine.h
+++ b/include/scratchcpp/virtualmachine.h
@@ -76,7 +76,7 @@ enum Opcode
     OP_STR_CONTAINS,   /*!< Stores true in the last register if the string stored in the second last register contains the substring in the last register. */
     OP_EXEC,           /*!< Calls the function with the index in the argument. */
     OP_INIT_PROCEDURE, /*!< Initializes the list of procedure (custom block) arguments. */
-    OP_CALL_PROCEDURE, /*! Calls the procedure (custom block) with the index in the argument. */
+    OP_CALL_PROCEDURE, /*!< Calls the procedure (custom block) with the index in the argument. */
     OP_ADD_ARG,        /*!< Adds a procedure (custom block) argument with the value from the last register. */
     OP_READ_ARG,       /*!< Reads the procedure (custom block) argument with the index in the argument and stores the value in the last register. */
     OP_BREAK_FRAME,    /*!< Breaks current frame at the end of the loop. */
@@ -88,6 +88,7 @@ enum Opcode
 class Target;
 class IEngine;
 class Script;
+class Thread;
 class List;
 
 /*! \brief The VirtualMachine class is a virtual machine for compiled Scratch scripts. */
@@ -95,7 +96,7 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
 {
     public:
         VirtualMachine();
-        VirtualMachine(Target *target, IEngine *engine, Script *script);
+        VirtualMachine(Target *target, IEngine *engine, Script *script, Thread *thread = nullptr);
         VirtualMachine(const VirtualMachine &) = delete;
 
         void setProcedures(unsigned int **procedures);
@@ -121,6 +122,7 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
         Target *target() const;
         IEngine *engine() const;
         Script *script() const;
+        Thread *thread() const;
 
         const Value *getInput(unsigned int index, unsigned int argCount) const;
 
diff --git a/src/blocks/CMakeLists.txt b/src/blocks/CMakeLists.txt
index c9aad324..d7416856 100644
--- a/src/blocks/CMakeLists.txt
+++ b/src/blocks/CMakeLists.txt
@@ -1,26 +1,115 @@
 target_sources(scratchcpp
   PRIVATE
-    standardblocks.cpp
-    standardblocks.h
-    motionblocks.cpp
-    looksblocks.cpp
-    soundblocks.cpp
-    eventblocks.cpp
-    controlblocks.cpp
-    sensingblocks.cpp
-    operatorblocks.cpp
-    variableblocks.cpp
-    listblocks.cpp
-    customblocks.cpp
-  PUBLIC
-    motionblocks.h
-    looksblocks.h
-    soundblocks.h
-    eventblocks.h
-    controlblocks.h
-    sensingblocks.h
-    operatorblocks.h
-    variableblocks.h
-    listblocks.h
-    customblocks.h
+    blocks.cpp
+    blocks.h
 )
+
+# Motion blocks
+option(LIBSCRATCHCPP_ENABLE_MOTION_BLOCKS "Motion blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_MOTION_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_MOTION_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        motionblocks.cpp
+        motionblocks.h
+    )
+endif()
+
+# Looks blocks
+option(LIBSCRATCHCPP_ENABLE_LOOKS_BLOCKS "Looks blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_LOOKS_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_LOOKS_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        looksblocks.cpp
+        looksblocks.h
+    )
+endif()
+
+# Sound blocks
+option(LIBSCRATCHCPP_ENABLE_SOUND_BLOCKS "Sound blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_SOUND_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_SOUND_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        soundblocks.cpp
+        soundblocks.h
+    )
+endif()
+
+# Event blocks
+option(LIBSCRATCHCPP_ENABLE_EVENT_BLOCKS "Event blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_EVENT_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_EVENT_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        eventblocks.cpp
+        eventblocks.h
+    )
+endif()
+
+# Control blocks
+option(LIBSCRATCHCPP_ENABLE_CONTROL_BLOCKS "Control blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_CONTROL_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_CONTROL_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        controlblocks.cpp
+        controlblocks.h
+    )
+endif()
+
+# Sensing blocks
+option(LIBSCRATCHCPP_ENABLE_SENSING_BLOCKS "Sensing blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_SENSING_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_SENSING_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        sensingblocks.cpp
+        sensingblocks.h
+    )
+endif()
+
+# Operator blocks
+option(LIBSCRATCHCPP_ENABLE_OPERATOR_BLOCKS "Operator blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_OPERATOR_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_OPERATOR_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        operatorblocks.cpp
+        operatorblocks.h
+    )
+endif()
+
+# Variable blocks
+option(LIBSCRATCHCPP_ENABLE_VARIABLE_BLOCKS "Variable blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_VARIABLE_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_VARIABLE_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        variableblocks.cpp
+        variableblocks.h
+    )
+endif()
+
+# List blocks
+option(LIBSCRATCHCPP_ENABLE_LIST_BLOCKS "List blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_LIST_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_LIST_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        listblocks.cpp
+        listblocks.h
+    )
+endif()
+
+# Custom blocks
+option(LIBSCRATCHCPP_ENABLE_CUSTOM_BLOCKS "Custom blocks support" ON)
+if (LIBSCRATCHCPP_ENABLE_CUSTOM_BLOCKS)
+    target_compile_definitions(scratchcpp PRIVATE ENABLE_CUSTOM_BLOCKS)
+    target_sources(scratchcpp
+      PRIVATE
+        customblocks.cpp
+        customblocks.h
+    )
+endif()
diff --git a/src/blocks/blocks.cpp b/src/blocks/blocks.cpp
new file mode 100644
index 00000000..a9d12f1e
--- /dev/null
+++ b/src/blocks/blocks.cpp
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <scratchcpp/scratchconfiguration.h>
+
+#include "blocks.h"
+
+#ifdef ENABLE_MOTION_BLOCKS
+#include "blocks/motionblocks.h"
+#endif
+#ifdef ENABLE_LOOKS_BLOCKS
+#include "blocks/looksblocks.h"
+#endif
+#ifdef ENABLE_SOUND_BLOCKS
+#include "blocks/soundblocks.h"
+#endif
+#ifdef ENABLE_EVENT_BLOCKS
+#include "blocks/eventblocks.h"
+#endif
+#ifdef ENABLE_CONTROL_BLOCKS
+#include "blocks/controlblocks.h"
+#endif
+#ifdef ENABLE_SENSING_BLOCKS
+#include "blocks/sensingblocks.h"
+#endif
+#ifdef ENABLE_OPERATOR_BLOCKS
+#include "blocks/operatorblocks.h"
+#endif
+#ifdef ENABLE_VARIABLE_BLOCKS
+#include "blocks/variableblocks.h"
+#endif
+#ifdef ENABLE_LIST_BLOCKS
+#include "blocks/listblocks.h"
+#endif
+#ifdef ENABLE_CUSTOM_BLOCKS
+#include "blocks/customblocks.h"
+#endif
+
+using namespace libscratchcpp;
+
+Blocks Blocks::m_instance;
+
+const std::vector<std::shared_ptr<IExtension>> &Blocks::extensions()
+{
+    return m_instance.m_extensions;
+}
+
+Blocks::Blocks()
+{
+#ifdef ENABLE_MOTION_BLOCKS
+    m_extensions.push_back(std::make_shared<MotionBlocks>());
+#endif
+#ifdef ENABLE_LOOKS_BLOCKS
+    m_extensions.push_back(std::make_shared<LooksBlocks>());
+#endif
+#ifdef ENABLE_SOUND_BLOCKS
+    m_extensions.push_back(std::make_shared<SoundBlocks>());
+#endif
+#ifdef ENABLE_EVENT_BLOCKS
+    m_extensions.push_back(std::make_shared<EventBlocks>());
+#endif
+#ifdef ENABLE_CONTROL_BLOCKS
+    m_extensions.push_back(std::make_shared<ControlBlocks>());
+#endif
+#ifdef ENABLE_SENSING_BLOCKS
+    m_extensions.push_back(std::make_shared<SensingBlocks>());
+#endif
+#ifdef ENABLE_OPERATOR_BLOCKS
+    m_extensions.push_back(std::make_shared<OperatorBlocks>());
+#endif
+#ifdef ENABLE_VARIABLE_BLOCKS
+    m_extensions.push_back(std::make_shared<VariableBlocks>());
+#endif
+#ifdef ENABLE_LIST_BLOCKS
+    m_extensions.push_back(std::make_shared<ListBlocks>());
+#endif
+#ifdef ENABLE_CUSTOM_BLOCKS
+    m_extensions.push_back(std::make_shared<CustomBlocks>());
+#endif
+}
+
+void Blocks::registerExtensions()
+{
+    for (auto ext : m_extensions)
+        ScratchConfiguration::registerExtension(ext);
+}
diff --git a/src/blocks/blocks.h b/src/blocks/blocks.h
new file mode 100644
index 00000000..56be7a34
--- /dev/null
+++ b/src/blocks/blocks.h
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <vector>
+#include <memory>
+
+namespace libscratchcpp
+{
+
+class IExtension;
+
+class Blocks
+{
+    public:
+        static const std::vector<std::shared_ptr<IExtension>> &extensions();
+
+    private:
+        Blocks();
+        void registerExtensions();
+
+        static Blocks m_instance; // use static initialization
+        std::vector<std::shared_ptr<IExtension>> m_extensions;
+};
+
+} // namespace libscratchcpp
diff --git a/src/blocks/controlblocks.cpp b/src/blocks/controlblocks.cpp
index 0f965123..ca3c4884 100644
--- a/src/blocks/controlblocks.cpp
+++ b/src/blocks/controlblocks.cpp
@@ -20,6 +20,11 @@ std::string ControlBlocks::name() const
     return "Control";
 }
 
+std::string ControlBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void ControlBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
@@ -204,7 +209,7 @@ unsigned int ControlBlocks::stopAll(VirtualMachine *vm)
 
 unsigned int ControlBlocks::stopOtherScriptsInSprite(VirtualMachine *vm)
 {
-    vm->engine()->stopTarget(vm->target(), vm);
+    vm->engine()->stopTarget(vm->target(), vm->thread());
     return 0;
 }
 
diff --git a/src/blocks/controlblocks.h b/src/blocks/controlblocks.h
index 236ab87b..aa0c8710 100644
--- a/src/blocks/controlblocks.h
+++ b/src/blocks/controlblocks.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 #include <unordered_map>
 #include <chrono>
 
@@ -14,7 +14,7 @@ class VirtualMachine;
 class IClock;
 
 /*! \brief The ControlBlocks class contains the implementation of control blocks. */
-class ControlBlocks : public IBlockSection
+class ControlBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -42,6 +42,7 @@ class ControlBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
 
diff --git a/src/blocks/customblocks.cpp b/src/blocks/customblocks.cpp
index 28a3a90b..aee3b757 100644
--- a/src/blocks/customblocks.cpp
+++ b/src/blocks/customblocks.cpp
@@ -15,6 +15,11 @@ std::string CustomBlocks::name() const
     return "Custom blocks";
 }
 
+std::string CustomBlocks::description() const
+{
+    return name();
+}
+
 void CustomBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
diff --git a/src/blocks/customblocks.h b/src/blocks/customblocks.h
index c115c307..a40e37c3 100644
--- a/src/blocks/customblocks.h
+++ b/src/blocks/customblocks.h
@@ -2,14 +2,14 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 
 namespace libscratchcpp
 {
 
 class Compiler;
 
-class CustomBlocks : public IBlockSection
+class CustomBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -23,6 +23,7 @@ class CustomBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
 
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index e4c61902..757e2bda 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -25,6 +25,11 @@ std::string EventBlocks::name() const
     return "Events";
 }
 
+std::string libscratchcpp::EventBlocks::description() const
+{
+    return "Event blocks";
+}
+
 void EventBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
@@ -96,55 +101,27 @@ void EventBlocks::compileWhenStageClicked(Compiler *compiler)
 
 void EventBlocks::compileBroadcast(Compiler *compiler)
 {
-    auto input = compiler->input(BROADCAST_INPUT);
-
-    if (input->type() != Input::Type::ObscuredShadow) {
-        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);
-    }
+    compiler->addInput(BROADCAST_INPUT);
+    compiler->addFunctionCall(&broadcast);
 }
 
 void EventBlocks::compileBroadcastAndWait(Compiler *compiler)
 {
-    auto input = compiler->input(BROADCAST_INPUT);
-
-    if (input->type() != Input::Type::ObscuredShadow) {
-        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);
-        compiler->addInput(input);
-        compiler->addFunctionCall(&checkBroadcast);
-    }
+    compiler->addInput(BROADCAST_INPUT);
+    compiler->addFunctionCall(&broadcastAndWait);
 }
 
 void EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
 {
-    auto broadcast = std::static_pointer_cast<Broadcast>(compiler->field(BROADCAST_OPTION)->valuePtr());
+    Field *field = compiler->field(BROADCAST_OPTION);
+    auto broadcast = std::static_pointer_cast<Broadcast>(field->valuePtr());
 
-    compiler->engine()->addBroadcastScript(compiler->block(), BROADCAST_OPTION, broadcast.get());
+    compiler->engine()->addBroadcastScript(compiler->block(), field, broadcast.get());
 }
 
 void EventBlocks::compileWhenBackdropSwitchesTo(Compiler *compiler)
 {
-    compiler->engine()->addBackdropChangeScript(compiler->block(), BACKDROP);
+    compiler->engine()->addBackdropChangeScript(compiler->block(), compiler->field(BACKDROP));
 }
 
 void EventBlocks::compileWhenGreaterThanPredicate(Compiler *compiler)
@@ -182,7 +159,7 @@ void EventBlocks::compileWhenGreaterThan(Compiler *compiler)
 void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
 {
     // NOTE: Field values don't have to be registered because keys are referenced by their names
-    compiler->engine()->addKeyPressScript(compiler->block(), KEY_OPTION);
+    compiler->engine()->addKeyPressScript(compiler->block(), compiler->field(KEY_OPTION));
 }
 
 unsigned int EventBlocks::whenTouchingObjectPredicate(VirtualMachine *vm)
@@ -210,14 +187,8 @@ unsigned int EventBlocks::broadcast(VirtualMachine *vm)
     std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());
 
     for (int index : broadcasts)
-        vm->engine()->broadcast(index);
-
-    return 1;
-}
+        vm->engine()->broadcast(index, vm->thread(), false);
 
-unsigned int EventBlocks::broadcastByIndex(VirtualMachine *vm)
-{
-    vm->engine()->broadcast(vm->getInput(0, 1)->toLong());
     return 1;
 }
 
@@ -226,43 +197,13 @@ unsigned int EventBlocks::broadcastAndWait(VirtualMachine *vm)
     std::vector<int> broadcasts = vm->engine()->findBroadcasts(vm->getInput(0, 1)->toString());
 
     for (int index : broadcasts)
-        vm->engine()->broadcast(index);
-
-    return 1;
-}
-
-unsigned int EventBlocks::broadcastByIndexAndWait(VirtualMachine *vm)
-{
-    vm->engine()->broadcast(vm->getInput(0, 1)->toLong());
-    return 1;
-}
-
-unsigned int EventBlocks::checkBroadcast(VirtualMachine *vm)
-{
-    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;
-        }
-    }
+        vm->engine()->broadcast(index, vm->thread(), true);
 
-    if (running)
-        vm->stop(true, true, true);
+    vm->promise();
 
     return 1;
 }
 
-unsigned int EventBlocks::checkBroadcastByIndex(VirtualMachine *vm)
-{
-    if (vm->engine()->broadcastRunning(vm->getInput(0, 1)->toLong()))
-        vm->stop(true, true, true);
-    return 1;
-}
-
 unsigned int EventBlocks::whenLoudnessGreaterThanPredicate(VirtualMachine *vm)
 {
     if (!audioInput)
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
index 0c5e5fd6..e4d28f4a 100644
--- a/src/blocks/eventblocks.h
+++ b/src/blocks/eventblocks.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 
 namespace libscratchcpp
 {
@@ -12,7 +12,7 @@ class VirtualMachine;
 class IAudioInput;
 
 /*! \brief The EventBlocks class contains the implementation of event blocks. */
-class EventBlocks : public IBlockSection
+class EventBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -37,6 +37,7 @@ class EventBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
 
@@ -56,11 +57,7 @@ class EventBlocks : public IBlockSection
         static unsigned int whenTouchingObjectPredicate(VirtualMachine *vm);
 
         static unsigned int broadcast(VirtualMachine *vm);
-        static unsigned int broadcastByIndex(VirtualMachine *vm);
         static unsigned int broadcastAndWait(VirtualMachine *vm);
-        static unsigned int broadcastByIndexAndWait(VirtualMachine *vm);
-        static unsigned int checkBroadcast(VirtualMachine *vm);
-        static unsigned int checkBroadcastByIndex(VirtualMachine *vm);
 
         static unsigned int whenLoudnessGreaterThanPredicate(VirtualMachine *vm);
         static unsigned int whenTimerGreaterThanPredicate(VirtualMachine *vm);
diff --git a/src/blocks/listblocks.cpp b/src/blocks/listblocks.cpp
index 03705deb..135dd0bd 100644
--- a/src/blocks/listblocks.cpp
+++ b/src/blocks/listblocks.cpp
@@ -5,6 +5,7 @@
 #include <scratchcpp/field.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/list.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/monitor.h>
 
@@ -17,9 +18,9 @@ std::string ListBlocks::name() const
     return "Lists";
 }
 
-bool ListBlocks::categoryVisible() const
+std::string ListBlocks::description() const
 {
-    return false;
+    return "List blocks";
 }
 
 void ListBlocks::registerBlocks(IEngine *engine)
@@ -141,11 +142,15 @@ void ListBlocks::compileHideList(Compiler *compiler)
         compiler->addFunctionCall(&hideList);
 }
 
-void ListBlocks::setListVisible(std::shared_ptr<List> list, bool visible)
+void ListBlocks::setListVisible(std::shared_ptr<List> list, bool visible, IEngine *engine)
 {
     if (list) {
-        assert(list->monitor());
-        list->monitor()->setVisible(visible);
+        Monitor *monitor = list->monitor();
+
+        if (!monitor)
+            monitor = engine->createListMonitor(list, "data_listcontents", "LIST", LIST, &compileListContents);
+
+        monitor->setVisible(visible);
     }
 }
 
@@ -153,7 +158,7 @@ unsigned int ListBlocks::showGlobalList(VirtualMachine *vm)
 {
     if (Stage *target = vm->engine()->stage()) {
         int index = target->findListById(vm->getInput(0, 1)->toString());
-        setListVisible(target->listAt(index), true);
+        setListVisible(target->listAt(index), true, vm->engine());
     }
 
     return 1;
@@ -162,8 +167,14 @@ unsigned int ListBlocks::showGlobalList(VirtualMachine *vm)
 unsigned int ListBlocks::showList(VirtualMachine *vm)
 {
     if (Target *target = vm->target()) {
-        int index = target->findListById(vm->getInput(0, 1)->toString());
-        setListVisible(target->listAt(index), true);
+        if (!target->isStage() && static_cast<Sprite *>(target)->isClone()) {
+            Sprite *sprite = static_cast<Sprite *>(target)->cloneSprite(); // use clone root list
+            int index = sprite->findListById(vm->getInput(0, 1)->toString());
+            setListVisible(sprite->listAt(index), true, vm->engine());
+        } else {
+            int index = target->findListById(vm->getInput(0, 1)->toString());
+            setListVisible(target->listAt(index), true, vm->engine());
+        }
     }
 
     return 1;
@@ -173,7 +184,7 @@ unsigned int ListBlocks::hideGlobalList(VirtualMachine *vm)
 {
     if (Stage *target = vm->engine()->stage()) {
         int index = target->findListById(vm->getInput(0, 1)->toString());
-        setListVisible(target->listAt(index), false);
+        setListVisible(target->listAt(index), false, vm->engine());
     }
 
     return 1;
@@ -182,8 +193,14 @@ unsigned int ListBlocks::hideGlobalList(VirtualMachine *vm)
 unsigned int ListBlocks::hideList(VirtualMachine *vm)
 {
     if (Target *target = vm->target()) {
-        int index = target->findListById(vm->getInput(0, 1)->toString());
-        setListVisible(target->listAt(index), false);
+        if (!target->isStage() && static_cast<Sprite *>(target)->isClone()) {
+            Sprite *sprite = static_cast<Sprite *>(target)->cloneSprite(); // use clone root list
+            int index = sprite->findListById(vm->getInput(0, 1)->toString());
+            setListVisible(sprite->listAt(index), false, vm->engine());
+        } else {
+            int index = target->findListById(vm->getInput(0, 1)->toString());
+            setListVisible(target->listAt(index), false, vm->engine());
+        }
     }
 
     return 1;
diff --git a/src/blocks/listblocks.h b/src/blocks/listblocks.h
index 1fdcbd12..69e49aa3 100644
--- a/src/blocks/listblocks.h
+++ b/src/blocks/listblocks.h
@@ -2,7 +2,8 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
+#include <memory>
 
 namespace libscratchcpp
 {
@@ -11,7 +12,7 @@ class Compiler;
 class List;
 
 /*! \brief The ListBlocks class contains the implementation of list blocks. */
-class ListBlocks : public IBlockSection
+class ListBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -26,7 +27,7 @@ class ListBlocks : public IBlockSection
         };
 
         std::string name() const override;
-        bool categoryVisible() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
 
@@ -43,7 +44,7 @@ class ListBlocks : public IBlockSection
         static void compileShowList(Compiler *compiler);
         static void compileHideList(Compiler *compiler);
 
-        static void setListVisible(std::shared_ptr<List> list, bool visible);
+        static void setListVisible(std::shared_ptr<List> list, bool visible, IEngine *engine);
 
         static unsigned int showGlobalList(VirtualMachine *vm);
         static unsigned int showList(VirtualMachine *vm);
diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index fb55f39d..5d2cf55a 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -2,6 +2,7 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/thread.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/input.h>
@@ -36,6 +37,11 @@ std::string LooksBlocks::name() const
     return "Looks";
 }
 
+std::string LooksBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void LooksBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
@@ -74,6 +80,7 @@ void LooksBlocks::registerBlocks(IEngine *engine)
     engine->addInput(this, "COSTUME", COSTUME);
     engine->addInput(this, "BACKDROP", BACKDROP);
     engine->addInput(this, "VALUE", VALUE);
+    engine->addInput(this, "NUM", NUM);
 
     // Fields
     engine->addField(this, "NUMBER_NAME", NUMBER_NAME);
@@ -99,16 +106,16 @@ void LooksBlocks::registerBlocks(IEngine *engine)
 
 void LooksBlocks::onInit(IEngine *engine)
 {
-    engine->threadAboutToStop().connect([](VirtualMachine *vm) {
-        m_timeMap.erase(vm);
-        erase_if(m_waitingBubbles, [vm](const std::pair<Target *, VirtualMachine *> &pair) { return pair.second == vm; });
+    engine->threadAboutToStop().connect([](Thread *thread) {
+        m_timeMap.erase(thread->vm());
+        erase_if(m_waitingBubbles, [thread](const std::pair<Target *, VirtualMachine *> &pair) { return pair.second == thread->vm(); });
     });
 
     engine->stopped().connect([engine]() {
         const auto &targets = engine->targets();
 
         for (auto target : targets) {
-            target->setBubbleText("");
+            target->bubble()->setText("");
             target->clearGraphicsEffects();
         }
     });
@@ -347,36 +354,8 @@ void LooksBlocks::compileSwitchCostumeTo(Compiler *compiler)
     if (!target)
         return;
 
-    Input *input = compiler->input(COSTUME);
-
-    if (input->pointsToDropdownMenu()) {
-        std::string value = input->selectedMenuItem();
-        int index = target->findCostume(value);
-
-        if (index == -1) {
-            if (value == "next costume")
-                compiler->addFunctionCall(&nextCostume);
-            else if (value == "previous costume")
-                compiler->addFunctionCall(&previousCostume);
-            else {
-                Value v(value);
-
-                if (v.type() == Value::Type::Integer) {
-                    compiler->addConstValue(v.toLong() - 1);
-                    compiler->addFunctionCall(&switchCostumeToByIndex);
-                } else {
-                    compiler->addInput(input);
-                    compiler->addFunctionCall(&switchCostumeTo);
-                }
-            }
-        } else {
-            compiler->addConstValue(index);
-            compiler->addFunctionCall(&switchCostumeToByIndex);
-        }
-    } else {
-        compiler->addInput(input);
-        compiler->addFunctionCall(&switchCostumeTo);
-    }
+    compiler->addInput(COSTUME);
+    compiler->addFunctionCall(&switchCostumeTo);
 }
 
 void LooksBlocks::compileNextCostume(Compiler *compiler)
@@ -386,87 +365,14 @@ void LooksBlocks::compileNextCostume(Compiler *compiler)
 
 void LooksBlocks::compileSwitchBackdropTo(Compiler *compiler)
 {
-    Stage *stage = compiler->engine()->stage();
-
-    if (!stage)
-        return;
-
-    Input *input = compiler->input(BACKDROP);
-
-    if (input->pointsToDropdownMenu()) {
-        std::string value = input->selectedMenuItem();
-        int index = stage->findCostume(value);
-
-        if (index == -1) {
-            if (value == "next backdrop")
-                compiler->addFunctionCall(&nextBackdrop);
-            else if (value == "previous backdrop")
-                compiler->addFunctionCall(&previousBackdrop);
-            else if (value == "random backdrop")
-                compiler->addFunctionCall(&randomBackdrop);
-            else {
-                Value v(value);
-
-                if (v.type() == Value::Type::Integer) {
-                    compiler->addConstValue(v.toLong() - 1);
-                    compiler->addFunctionCall(&switchBackdropToByIndex);
-                } else {
-                    compiler->addInput(input);
-                    compiler->addFunctionCall(&switchBackdropTo);
-                }
-            }
-        } else {
-            compiler->addConstValue(index);
-            compiler->addFunctionCall(&switchBackdropToByIndex);
-        }
-    } else {
-        compiler->addInput(input);
-        compiler->addFunctionCall(&switchBackdropTo);
-    }
+    compiler->addInput(BACKDROP);
+    compiler->addFunctionCall(&switchBackdropTo);
 }
 
 void LooksBlocks::compileSwitchBackdropToAndWait(Compiler *compiler)
 {
-    Stage *stage = compiler->engine()->stage();
-
-    if (!stage)
-        return;
-
-    Input *input = compiler->input(BACKDROP);
-
-    if (input->pointsToDropdownMenu()) {
-        std::string value = input->selectedMenuItem();
-        int index = stage->findCostume(value);
-
-        if (index == -1) {
-            if (value == "next backdrop")
-                compiler->addFunctionCall(&nextBackdropAndWait);
-            else if (value == "previous backdrop")
-                compiler->addFunctionCall(&previousBackdropAndWait);
-            else if (value == "random backdrop")
-                compiler->addFunctionCall(&randomBackdropAndWait);
-            else {
-                Value v(value);
-
-                if (v.type() == Value::Type::Integer) {
-                    compiler->addConstValue(v.toLong() - 1);
-                    compiler->addFunctionCall(&switchBackdropToByIndexAndWait);
-                } else {
-                    compiler->addInput(input);
-                    compiler->addFunctionCall(&switchBackdropToAndWait);
-                }
-            }
-        } else {
-            compiler->addConstValue(index);
-            compiler->addFunctionCall(&switchBackdropToByIndexAndWait);
-        }
-    } else {
-        compiler->addInput(input);
-        compiler->addFunctionCall(&switchBackdropToAndWait);
-    }
-
-    compiler->addFunctionCall(&backdropNumber);
-    compiler->addFunctionCall(&checkBackdropScripts);
+    compiler->addInput(BACKDROP);
+    compiler->addFunctionCall(&switchBackdropToAndWait);
 }
 
 void LooksBlocks::compileNextBackdrop(Compiler *compiler)
@@ -614,13 +520,13 @@ bool LooksBlocks::wait(VirtualMachine *vm)
     }
 }
 
-void LooksBlocks::showBubble(VirtualMachine *vm, Target::BubbleType type, const std::string &text)
+void LooksBlocks::showBubble(VirtualMachine *vm, TextBubble::Type type, const std::string &text)
 {
     Target *target = vm->target();
 
     if (target) {
-        target->setBubbleType(type);
-        target->setBubbleText(text);
+        target->bubble()->setType(type);
+        target->bubble()->setText(text);
         m_waitingBubbles.erase(target);
     }
 }
@@ -630,7 +536,7 @@ void LooksBlocks::hideBubble(Target *target)
     if (!target)
         return;
 
-    target->setBubbleText("");
+    target->bubble()->setText("");
     m_waitingBubbles.erase(target);
 }
 
@@ -639,7 +545,7 @@ unsigned int LooksBlocks::startSayForSecs(VirtualMachine *vm)
     Target *target = vm->target();
 
     if (target) {
-        showBubble(vm, Target::BubbleType::Say, vm->getInput(0, 2)->toString());
+        showBubble(vm, TextBubble::Type::Say, vm->getInput(0, 2)->toString());
         m_waitingBubbles[target] = vm;
         startWait(vm, vm->getInput(1, 2)->toDouble());
     }
@@ -666,7 +572,7 @@ unsigned int LooksBlocks::sayForSecs(VirtualMachine *vm)
 
 unsigned int LooksBlocks::say(VirtualMachine *vm)
 {
-    showBubble(vm, Target::BubbleType::Say, vm->getInput(0, 1)->toString());
+    showBubble(vm, TextBubble::Type::Say, vm->getInput(0, 1)->toString());
     return 1;
 }
 
@@ -675,7 +581,7 @@ unsigned int LooksBlocks::startThinkForSecs(VirtualMachine *vm)
     Target *target = vm->target();
 
     if (target) {
-        showBubble(vm, Target::BubbleType::Think, vm->getInput(0, 2)->toString());
+        showBubble(vm, TextBubble::Type::Think, vm->getInput(0, 2)->toString());
         m_waitingBubbles[target] = vm;
         startWait(vm, vm->getInput(1, 2)->toDouble());
     }
@@ -690,7 +596,7 @@ unsigned int LooksBlocks::thinkForSecs(VirtualMachine *vm)
 
 unsigned int LooksBlocks::think(VirtualMachine *vm)
 {
-    showBubble(vm, Target::BubbleType::Think, vm->getInput(0, 1)->toString());
+    showBubble(vm, TextBubble::Type::Think, vm->getInput(0, 1)->toString());
     return 1;
 }
 
@@ -932,36 +838,43 @@ void LooksBlocks::setCostumeByIndex(Target *target, long index)
     target->setCostumeIndex(index);
 }
 
-unsigned int LooksBlocks::switchCostumeToByIndex(VirtualMachine *vm)
-{
-    if (Target *target = vm->target())
-        setCostumeByIndex(target, vm->getInput(0, 1)->toLong());
-
-    return 1;
-}
-
 unsigned int LooksBlocks::switchCostumeTo(VirtualMachine *vm)
 {
+    // https://github.com/scratchfoundation/scratch-vm/blob/8dbcc1fc8f8d8c4f1e40629fe8a388149d6dfd1c/src/blocks/scratch3_looks.js#L389-L413
     Target *target = vm->target();
 
     if (!target)
         return 1;
 
     const Value *name = vm->getInput(0, 1);
-    std::string nameStr = name->toString();
-    int index = target->findCostume(nameStr);
 
-    if (index == -1) {
-        if (nameStr == "next costume")
+    if (!name->isString()) {
+        // Numbers should be treated as costume indices, always
+        if (name->isNaN() || name->isInfinity() || name->isNegativeInfinity())
+            target->setCostumeIndex(0);
+        else
+            setCostumeByIndex(target, name->toLong() - 1);
+    } else {
+        // Strings should be treated as costume names, where possible
+        const int costumeIndex = target->findCostume(name->toString());
+        std::string nameStr = name->toString();
+
+        auto it = std::find_if(nameStr.begin(), nameStr.end(), [](char c) { return !std::isspace(c); });
+        bool isWhiteSpace = (it == nameStr.end());
+
+        if (costumeIndex != -1) {
+            setCostumeByIndex(target, costumeIndex);
+        } else if (nameStr == "next costume") {
             nextCostume(vm);
-        else if (nameStr == "previous costume")
+        } else if (nameStr == "previous costume") {
             previousCostume(vm);
-        else {
-            if (name->isValidNumber())
-                setCostumeByIndex(target, name->toLong() - 1);
+            // Try to cast the string to a number (and treat it as a costume index)
+            // Pure whitespace should not be treated as a number
+            // Note: isNaN will cast the string to a number before checking if it's NaN
+        } else if (!(name->isNaN() || isWhiteSpace)) {
+            target->setCostumeIndex(name->toInt() - 1);
         }
-    } else
-        setCostumeByIndex(target, index);
+    }
 
     return 1;
 }
@@ -986,40 +899,49 @@ void LooksBlocks::startBackdropScripts(VirtualMachine *vm, bool wait)
 {
     if (Stage *stage = vm->engine()->stage()) {
         if (stage->costumes().size() > 0)
-            vm->engine()->startBackdropScripts(stage->currentCostume()->broadcast());
+            vm->engine()->startBackdropScripts(stage->currentCostume()->broadcast(), vm->thread(), wait);
     }
 }
 
-void LooksBlocks::switchBackdropToByIndexImpl(VirtualMachine *vm)
-{
-    if (Stage *stage = vm->engine()->stage())
-        setCostumeByIndex(stage, vm->getInput(0, 1)->toLong());
-}
-
 void LooksBlocks::switchBackdropToImpl(VirtualMachine *vm)
 {
+    // https://github.com/scratchfoundation/scratch-vm/blob/8dbcc1fc8f8d8c4f1e40629fe8a388149d6dfd1c/src/blocks/scratch3_looks.js#L423-L462
     Stage *stage = vm->engine()->stage();
 
     if (!stage)
         return;
 
     const Value *name = vm->getInput(0, 1);
-    std::string nameStr = name->toString();
-    int index = stage->findCostume(nameStr);
 
-    if (index == -1) {
-        if (nameStr == "next backdrop")
+    if (!name->isString()) {
+        // Numbers should be treated as costume indices, always
+        if (name->isNaN() || name->isInfinity() || name->isNegativeInfinity())
+            stage->setCostumeIndex(0);
+        else
+            setCostumeByIndex(stage, name->toLong() - 1);
+    } else {
+        // Strings should be treated as costume names, where possible
+        const int costumeIndex = stage->findCostume(name->toString());
+        std::string nameStr = name->toString();
+
+        auto it = std::find_if(nameStr.begin(), nameStr.end(), [](char c) { return !std::isspace(c); });
+        bool isWhiteSpace = (it == nameStr.end());
+
+        if (costumeIndex != -1) {
+            setCostumeByIndex(stage, costumeIndex);
+        } else if (nameStr == "next backdrop") {
             nextBackdropImpl(vm);
-        else if (nameStr == "previous backdrop")
+        } else if (nameStr == "previous backdrop") {
             previousBackdropImpl(vm);
-        else if (nameStr == "random backdrop") {
+        } else if (nameStr == "random backdrop") {
             randomBackdropImpl(vm);
-        } else {
-            if (name->isValidNumber())
-                setCostumeByIndex(stage, name->toLong() - 1);
+            // Try to cast the string to a number (and treat it as a costume index)
+            // Pure whitespace should not be treated as a number
+            // Note: isNaN will cast the string to a number before checking if it's NaN
+        } else if (!(name->isNaN() || isWhiteSpace)) {
+            stage->setCostumeIndex(name->toInt() - 1);
         }
-    } else
-        setCostumeByIndex(stage, index);
+    }
 }
 
 void LooksBlocks::nextBackdropImpl(VirtualMachine *vm)
@@ -1047,14 +969,6 @@ void LooksBlocks::randomBackdropImpl(VirtualMachine *vm)
     }
 }
 
-unsigned int LooksBlocks::switchBackdropToByIndex(VirtualMachine *vm)
-{
-    switchBackdropToByIndexImpl(vm);
-    startBackdropScripts(vm, false);
-
-    return 1;
-}
-
 unsigned int LooksBlocks::switchBackdropTo(VirtualMachine *vm)
 {
     switchBackdropToImpl(vm);
@@ -1063,18 +977,11 @@ unsigned int LooksBlocks::switchBackdropTo(VirtualMachine *vm)
     return 1;
 }
 
-unsigned int LooksBlocks::switchBackdropToByIndexAndWait(VirtualMachine *vm)
-{
-    switchBackdropToByIndexImpl(vm);
-    startBackdropScripts(vm, true);
-
-    return 1;
-}
-
 unsigned int LooksBlocks::switchBackdropToAndWait(VirtualMachine *vm)
 {
     switchBackdropToImpl(vm);
     startBackdropScripts(vm, true);
+    vm->promise();
 
     return 1;
 }
@@ -1087,14 +994,6 @@ unsigned int LooksBlocks::nextBackdrop(VirtualMachine *vm)
     return 0;
 }
 
-unsigned int LooksBlocks::nextBackdropAndWait(VirtualMachine *vm)
-{
-    nextBackdropImpl(vm);
-    startBackdropScripts(vm, true);
-
-    return 0;
-}
-
 unsigned int LooksBlocks::previousBackdrop(VirtualMachine *vm)
 {
     previousBackdropImpl(vm);
@@ -1103,14 +1002,6 @@ unsigned int LooksBlocks::previousBackdrop(VirtualMachine *vm)
     return 0;
 }
 
-unsigned int LooksBlocks::previousBackdropAndWait(VirtualMachine *vm)
-{
-    previousBackdropImpl(vm);
-    startBackdropScripts(vm, true);
-
-    return 0;
-}
-
 unsigned int LooksBlocks::randomBackdrop(VirtualMachine *vm)
 {
     randomBackdropImpl(vm);
@@ -1119,33 +1010,12 @@ unsigned int LooksBlocks::randomBackdrop(VirtualMachine *vm)
     return 0;
 }
 
-unsigned int LooksBlocks::randomBackdropAndWait(VirtualMachine *vm)
-{
-    randomBackdropImpl(vm);
-    startBackdropScripts(vm, true);
-
-    return 0;
-}
-
-unsigned int LooksBlocks::checkBackdropScripts(VirtualMachine *vm)
-{
-    if (Stage *stage = vm->engine()->stage()) {
-        long index = vm->getInput(0, 1)->toLong() - 1;
-        assert(stage->costumes().size() == 0 || index >= 0);
-
-        if ((stage->costumes().size() > 0) && vm->engine()->broadcastByPtrRunning(stage->costumeAt(index)->broadcast()))
-            vm->stop(true, true, true);
-    }
-
-    return 1;
-}
-
 unsigned int LooksBlocks::goToFront(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
 
     if (sprite)
-        vm->engine()->moveSpriteToFront(sprite);
+        vm->engine()->moveDrawableToFront(sprite);
 
     return 0;
 }
@@ -1155,7 +1025,7 @@ unsigned int LooksBlocks::goToBack(VirtualMachine *vm)
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
 
     if (sprite)
-        vm->engine()->moveSpriteToBack(sprite);
+        vm->engine()->moveDrawableToBack(sprite);
 
     return 0;
 }
@@ -1165,7 +1035,7 @@ unsigned int LooksBlocks::goForwardLayers(VirtualMachine *vm)
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
 
     if (sprite)
-        vm->engine()->moveSpriteForwardLayers(sprite, vm->getInput(0, 1)->toInt());
+        vm->engine()->moveDrawableForwardLayers(sprite, vm->getInput(0, 1)->toInt());
 
     return 1;
 }
@@ -1175,7 +1045,7 @@ unsigned int LooksBlocks::goBackwardLayers(VirtualMachine *vm)
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());
 
     if (sprite)
-        vm->engine()->moveSpriteBackwardLayers(sprite, vm->getInput(0, 1)->toInt());
+        vm->engine()->moveDrawableBackwardLayers(sprite, vm->getInput(0, 1)->toInt());
 
     return 1;
 }
diff --git a/src/blocks/looksblocks.h b/src/blocks/looksblocks.h
index 60d54fc5..8881d7eb 100644
--- a/src/blocks/looksblocks.h
+++ b/src/blocks/looksblocks.h
@@ -2,8 +2,9 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 #include <scratchcpp/target.h>
+#include <scratchcpp/textbubble.h>
 #include <vector>
 #include <unordered_map>
 #include <chrono>
@@ -17,8 +18,7 @@ class IGraphicsEffect;
 class IRandomGenerator;
 class IClock;
 
-/*! \brief The LooksBlocks class contains the implementation of looks blocks. */
-class LooksBlocks : public IBlockSection
+class LooksBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -59,6 +59,7 @@ class LooksBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
         void onInit(IEngine *engine) override;
@@ -91,7 +92,7 @@ class LooksBlocks : public IBlockSection
 
         static void startWait(VirtualMachine *vm, double secs);
         static bool wait(VirtualMachine *vm);
-        static void showBubble(VirtualMachine *vm, Target::BubbleType type, const std::string &text);
+        static void showBubble(VirtualMachine *vm, TextBubble::Type type, const std::string &text);
         static void hideBubble(Target *target);
 
         static unsigned int startSayForSecs(VirtualMachine *vm);
@@ -129,29 +130,21 @@ class LooksBlocks : public IBlockSection
         static unsigned int size(VirtualMachine *vm);
 
         static void setCostumeByIndex(Target *target, long index);
-        static unsigned int switchCostumeToByIndex(VirtualMachine *vm);
         static unsigned int switchCostumeTo(VirtualMachine *vm);
         static unsigned int nextCostume(VirtualMachine *vm);
         static unsigned int previousCostume(VirtualMachine *vm);
 
         static void startBackdropScripts(VirtualMachine *vm, bool wait);
-        static void switchBackdropToByIndexImpl(VirtualMachine *vm);
         static void switchBackdropToImpl(VirtualMachine *vm);
         static void nextBackdropImpl(VirtualMachine *vm);
         static void previousBackdropImpl(VirtualMachine *vm);
         static void randomBackdropImpl(VirtualMachine *vm);
 
-        static unsigned int switchBackdropToByIndex(VirtualMachine *vm);
         static unsigned int switchBackdropTo(VirtualMachine *vm);
-        static unsigned int switchBackdropToByIndexAndWait(VirtualMachine *vm);
         static unsigned int switchBackdropToAndWait(VirtualMachine *vm);
         static unsigned int nextBackdrop(VirtualMachine *vm);
-        static unsigned int nextBackdropAndWait(VirtualMachine *vm);
         static unsigned int previousBackdrop(VirtualMachine *vm);
-        static unsigned int previousBackdropAndWait(VirtualMachine *vm);
         static unsigned int randomBackdrop(VirtualMachine *vm);
-        static unsigned int randomBackdropAndWait(VirtualMachine *vm);
-        static unsigned int checkBackdropScripts(VirtualMachine *vm);
 
         static unsigned int goToFront(VirtualMachine *vm);
         static unsigned int goToBack(VirtualMachine *vm);
diff --git a/src/blocks/motionblocks.cpp b/src/blocks/motionblocks.cpp
index 549cb18d..c5a96004 100644
--- a/src/blocks/motionblocks.cpp
+++ b/src/blocks/motionblocks.cpp
@@ -2,6 +2,7 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/thread.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
@@ -23,6 +24,11 @@ std::string MotionBlocks::name() const
     return "Motion";
 }
 
+std::string MotionBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void MotionBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
@@ -73,9 +79,9 @@ void MotionBlocks::registerBlocks(IEngine *engine)
 
 void MotionBlocks::onInit(IEngine *engine)
 {
-    engine->threadAboutToStop().connect([](VirtualMachine *vm) {
-        m_timeMap.erase(vm);
-        m_glideMap.erase(vm);
+    engine->threadAboutToStop().connect([](Thread *thread) {
+        m_timeMap.erase(thread->vm());
+        m_glideMap.erase(thread->vm());
     });
 }
 
diff --git a/src/blocks/motionblocks.h b/src/blocks/motionblocks.h
index 0b62ee59..b545822e 100644
--- a/src/blocks/motionblocks.h
+++ b/src/blocks/motionblocks.h
@@ -5,7 +5,7 @@
 #include <unordered_map>
 #include <chrono>
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 
 namespace libscratchcpp
 {
@@ -14,8 +14,7 @@ class Sprite;
 class IRandomGenerator;
 class IClock;
 
-/*! \brief The MotionBlocks class contains the implementation of motion blocks. */
-class MotionBlocks : public IBlockSection
+class MotionBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -45,6 +44,7 @@ class MotionBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
         void onInit(IEngine *engine) override;
diff --git a/src/blocks/operatorblocks.cpp b/src/blocks/operatorblocks.cpp
index 58851344..cd200ad6 100644
--- a/src/blocks/operatorblocks.cpp
+++ b/src/blocks/operatorblocks.cpp
@@ -13,6 +13,11 @@ std::string OperatorBlocks::name() const
     return "Operators";
 }
 
+std::string OperatorBlocks::description() const
+{
+    return "Operator blocks";
+}
+
 void OperatorBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
@@ -256,9 +261,9 @@ unsigned int OperatorBlocks::op_ln(VirtualMachine *vm)
 {
     const Value &v = *vm->getInput(0, 1);
     if (v < 0)
-        vm->replaceReturnValue(Value(Value::SpecialValue::NaN), 1);
+        vm->replaceReturnValue(Value(SpecialValue::NaN), 1);
     else if (v == 0 || v.isNaN())
-        vm->replaceReturnValue(Value(Value::SpecialValue::NegativeInfinity), 1);
+        vm->replaceReturnValue(Value(SpecialValue::NegativeInfinity), 1);
     else if (!v.isInfinity())
         vm->replaceReturnValue(std::log(v.toDouble()), 1);
     return 0;
@@ -268,9 +273,9 @@ unsigned int OperatorBlocks::op_log(VirtualMachine *vm)
 {
     const Value &v = *vm->getInput(0, 1);
     if (v < 0)
-        vm->replaceReturnValue(Value(Value::SpecialValue::NaN), 1);
+        vm->replaceReturnValue(Value(SpecialValue::NaN), 1);
     else if (v == 0 || v.isNaN())
-        vm->replaceReturnValue(Value(Value::SpecialValue::NegativeInfinity), 1);
+        vm->replaceReturnValue(Value(SpecialValue::NegativeInfinity), 1);
     else if (!v.isInfinity())
         vm->replaceReturnValue(std::log10(v.toDouble()), 1);
     return 0;
diff --git a/src/blocks/operatorblocks.h b/src/blocks/operatorblocks.h
index 03b09faa..e9dd932a 100644
--- a/src/blocks/operatorblocks.h
+++ b/src/blocks/operatorblocks.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 
 namespace libscratchcpp
 {
@@ -11,7 +11,7 @@ class Compiler;
 class VirtualMachine;
 
 /*! \brief The OperatorBlocks class contains the implementation of operator blocks. */
-class OperatorBlocks : public IBlockSection
+class OperatorBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -54,6 +54,7 @@ class OperatorBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
 
diff --git a/src/blocks/sensingblocks.cpp b/src/blocks/sensingblocks.cpp
index fee64bc0..a1ef1c55 100644
--- a/src/blocks/sensingblocks.cpp
+++ b/src/blocks/sensingblocks.cpp
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/virtualmachine.h>
+#include <scratchcpp/thread.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/itimer.h>
@@ -8,6 +9,7 @@
 #include <scratchcpp/field.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
+#include <scratchcpp/textbubble.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/block.h>
@@ -27,11 +29,17 @@ std::string SensingBlocks::name() const
     return "Sensing";
 }
 
+std::string SensingBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void SensingBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
     engine->addCompileFunction(this, "sensing_touchingobject", &compileTouchingObject);
     engine->addCompileFunction(this, "sensing_touchingcolor", &compileTouchingColor);
+    engine->addCompileFunction(this, "sensing_coloristouchingcolor", &compileColorIsTouchingColor);
     engine->addCompileFunction(this, "sensing_distanceto", &compileDistanceTo);
     engine->addCompileFunction(this, "sensing_askandwait", &compileAskAndWait);
     engine->addCompileFunction(this, "sensing_answer", &compileAnswer);
@@ -60,6 +68,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     // Inputs
     engine->addInput(this, "TOUCHINGOBJECTMENU", TOUCHINGOBJECTMENU);
     engine->addInput(this, "COLOR", COLOR);
+    engine->addInput(this, "COLOR2", COLOR2);
     engine->addInput(this, "DISTANCETOMENU", DISTANCETOMENU);
     engine->addInput(this, "QUESTION", QUESTION);
     engine->addInput(this, "KEY_OPTION", KEY_OPTION);
@@ -97,16 +106,17 @@ void SensingBlocks::registerBlocks(IEngine *engine)
 
 void SensingBlocks::onInit(IEngine *engine)
 {
-    engine->threadAboutToStop().connect([engine](VirtualMachine *thread) {
+    engine->threadAboutToStop().connect([engine](Thread *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("");
+            if (m_questionList.front()->vm == thread->vm()) {
+                thread->target()->bubble()->setText("");
                 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());
+            m_questionList.erase(
+                std::remove_if(m_questionList.begin(), m_questionList.end(), [thread](const std::unique_ptr<Question> &question) { return question->vm == thread->vm(); }),
+                m_questionList.end());
         }
     });
 }
@@ -139,6 +149,13 @@ void SensingBlocks::compileTouchingColor(Compiler *compiler)
     compiler->addFunctionCall(&touchingColor);
 }
 
+void SensingBlocks::compileColorIsTouchingColor(Compiler *compiler)
+{
+    compiler->addInput(COLOR2); // target color
+    compiler->addInput(COLOR);  // mask color
+    compiler->addFunctionCall(&colorIsTouchingColor);
+}
+
 void SensingBlocks::compileDistanceTo(Compiler *compiler)
 {
     Input *input = compiler->input(DISTANCETOMENU);
@@ -525,6 +542,12 @@ unsigned int SensingBlocks::touchingColor(VirtualMachine *vm)
     return 0;
 }
 
+unsigned int SensingBlocks::colorIsTouchingColor(VirtualMachine *vm)
+{
+    vm->replaceReturnValue(vm->target()->touchingColor(*vm->getInput(0, 2), *vm->getInput(1, 2)), 2);
+    return 1;
+}
+
 unsigned int SensingBlocks::keyPressed(VirtualMachine *vm)
 {
     vm->replaceReturnValue(vm->engine()->keyPressed(vm->getInput(0, 1)->toString()), 1);
@@ -650,7 +673,7 @@ void SensingBlocks::onAnswer(const std::string &answer)
 
         // If the target was visible when asked, hide the say bubble unless the target was the stage
         if (question->wasVisible && !question->wasStage)
-            vm->target()->setBubbleText("");
+            vm->target()->bubble()->setText("");
 
         m_questionList.erase(m_questionList.begin());
         vm->resolvePromise();
@@ -1062,8 +1085,8 @@ void SensingBlocks::askNextQuestion()
     // If the target is visible, emit a blank question and show
     // a bubble unless the target was the stage
     if (question->wasVisible && !question->wasStage) {
-        target->setBubbleType(Target::BubbleType::Say);
-        target->setBubbleText(question->question);
+        target->bubble()->setType(TextBubble::Type::Say);
+        target->bubble()->setText(question->question);
 
         engine->questionAsked()("");
     } else {
diff --git a/src/blocks/sensingblocks.h b/src/blocks/sensingblocks.h
index e281827f..8153a18b 100644
--- a/src/blocks/sensingblocks.h
+++ b/src/blocks/sensingblocks.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 #include <scratchcpp/value.h>
 #include <vector>
 
@@ -15,13 +15,14 @@ class Target;
 class IAudioInput;
 
 /*! \brief The SensingBlocks class contains the implementation of sensing blocks. */
-class SensingBlocks : public IBlockSection
+class SensingBlocks : public IExtension
 {
     public:
         enum Inputs
         {
             TOUCHINGOBJECTMENU,
             COLOR,
+            COLOR2,
             DISTANCETOMENU,
             QUESTION,
             KEY_OPTION,
@@ -58,12 +59,14 @@ class SensingBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
         void onInit(IEngine *engine) override;
 
         static void compileTouchingObject(Compiler *compiler);
         static void compileTouchingColor(Compiler *compiler);
+        static void compileColorIsTouchingColor(Compiler *compiler);
         static void compileDistanceTo(Compiler *compiler);
         static void compileAskAndWait(Compiler *compiler);
         static void compileAnswer(Compiler *compiler);
@@ -95,6 +98,8 @@ class SensingBlocks : public IBlockSection
 
         static unsigned int touchingColor(VirtualMachine *vm);
 
+        static unsigned int colorIsTouchingColor(VirtualMachine *vm);
+
         static unsigned int keyPressed(VirtualMachine *vm);
         static unsigned int mouseDown(VirtualMachine *vm);
         static unsigned int mouseX(VirtualMachine *vm);
diff --git a/src/blocks/soundblocks.cpp b/src/blocks/soundblocks.cpp
index 4eb311fa..6cc2aa7b 100644
--- a/src/blocks/soundblocks.cpp
+++ b/src/blocks/soundblocks.cpp
@@ -6,6 +6,7 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/sound.h>
+#include <scratchcpp/thread.h>
 
 #include "soundblocks.h"
 
@@ -28,6 +29,11 @@ std::string SoundBlocks::name() const
     return "Sound";
 }
 
+std::string SoundBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void SoundBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
@@ -60,7 +66,7 @@ void SoundBlocks::registerBlocks(IEngine *engine)
 void SoundBlocks::onInit(IEngine *engine)
 {
     m_waitingSounds.clear();
-    engine->threadAboutToStop().connect([](VirtualMachine *vm) { erase_if(m_waitingSounds, [vm](const std::pair<Sound *, VirtualMachine *> &pair) { return pair.second == vm; }); });
+    engine->threadAboutToStop().connect([](Thread *thread) { erase_if(m_waitingSounds, [thread](const std::pair<Sound *, VirtualMachine *> &pair) { return pair.second == thread->vm(); }); });
 }
 
 bool SoundBlocks::compilePlayCommon(Compiler *compiler, bool untilDone, bool *byIndex)
diff --git a/src/blocks/soundblocks.h b/src/blocks/soundblocks.h
index 10e493c5..d31b8a62 100644
--- a/src/blocks/soundblocks.h
+++ b/src/blocks/soundblocks.h
@@ -5,7 +5,7 @@
 #include <unordered_map>
 #include <unordered_set>
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 
 namespace libscratchcpp
 {
@@ -14,7 +14,7 @@ class Sound;
 class Target;
 
 /*! \brief The SoundBlocks class contains the implementation of sound blocks. */
-class SoundBlocks : public IBlockSection
+class SoundBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -36,6 +36,7 @@ class SoundBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
         void onInit(IEngine *engine) override;
diff --git a/src/blocks/standardblocks.cpp b/src/blocks/standardblocks.cpp
deleted file mode 100644
index 42b23080..00000000
--- a/src/blocks/standardblocks.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-#include <scratchcpp/iengine.h>
-
-#include "standardblocks.h"
-#include "controlblocks.h"
-#include "eventblocks.h"
-#include "motionblocks.h"
-#include "looksblocks.h"
-#include "soundblocks.h"
-#include "sensingblocks.h"
-#include "operatorblocks.h"
-#include "variableblocks.h"
-#include "listblocks.h"
-#include "customblocks.h"
-
-using namespace libscratchcpp;
-
-std::string StandardBlocks::name() const
-{
-    return "Standard Blocks";
-}
-
-std::string StandardBlocks::description() const
-{
-    return "Default blocks included with Scratch";
-}
-
-bool StandardBlocks::includeByDefault() const
-{
-    return true;
-}
-
-void StandardBlocks::registerSections(IEngine *engine)
-{
-    engine->registerSection(std::make_shared<MotionBlocks>());
-    engine->registerSection(std::make_shared<LooksBlocks>());
-    engine->registerSection(std::make_shared<SoundBlocks>());
-    engine->registerSection(std::make_shared<EventBlocks>());
-    engine->registerSection(std::make_shared<ControlBlocks>());
-    engine->registerSection(std::make_shared<SensingBlocks>());
-    engine->registerSection(std::make_shared<OperatorBlocks>());
-    engine->registerSection(std::make_shared<VariableBlocks>());
-    engine->registerSection(std::make_shared<ListBlocks>());
-    engine->registerSection(std::make_shared<CustomBlocks>());
-}
diff --git a/src/blocks/standardblocks.h b/src/blocks/standardblocks.h
deleted file mode 100644
index 945f1dde..00000000
--- a/src/blocks/standardblocks.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-#pragma once
-
-#include <scratchcpp/iextension.h>
-
-namespace libscratchcpp
-{
-
-/*! \brief The StandardBlocks class provides the default Scratch blocks. */
-class StandardBlocks : public IExtension
-{
-    public:
-        std::string name() const override;
-        std::string description() const override;
-        bool includeByDefault() const override;
-
-        void registerSections(IEngine *engine) override;
-};
-
-} // namespace libscratchcpp
diff --git a/src/blocks/variableblocks.cpp b/src/blocks/variableblocks.cpp
index 668bd56b..81961e49 100644
--- a/src/blocks/variableblocks.cpp
+++ b/src/blocks/variableblocks.cpp
@@ -5,6 +5,7 @@
 #include <scratchcpp/field.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/variable.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/monitor.h>
 
@@ -17,6 +18,11 @@ std::string VariableBlocks::name() const
     return "Variables";
 }
 
+std::string VariableBlocks::description() const
+{
+    return "Variable blocks";
+}
+
 void VariableBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
@@ -87,11 +93,15 @@ void VariableBlocks::compileHideVariable(Compiler *compiler)
         compiler->addFunctionCall(&hideVariable);
 }
 
-void VariableBlocks::setVarVisible(std::shared_ptr<Variable> var, bool visible)
+void VariableBlocks::setVarVisible(std::shared_ptr<Variable> var, bool visible, IEngine *engine)
 {
     if (var) {
-        assert(var->monitor());
-        var->monitor()->setVisible(visible);
+        Monitor *monitor = var->monitor();
+
+        if (!monitor)
+            monitor = engine->createVariableMonitor(var, "data_variable", "VARIABLE", VARIABLE, &compileVariable);
+
+        monitor->setVisible(visible);
     }
 }
 
@@ -99,7 +109,7 @@ unsigned int VariableBlocks::showGlobalVariable(VirtualMachine *vm)
 {
     if (Stage *target = vm->engine()->stage()) {
         int index = target->findVariableById(vm->getInput(0, 1)->toString());
-        setVarVisible(target->variableAt(index), true);
+        setVarVisible(target->variableAt(index), true, vm->engine());
     }
 
     return 1;
@@ -108,8 +118,14 @@ unsigned int VariableBlocks::showGlobalVariable(VirtualMachine *vm)
 unsigned int VariableBlocks::showVariable(VirtualMachine *vm)
 {
     if (Target *target = vm->target()) {
-        int index = target->findVariableById(vm->getInput(0, 1)->toString());
-        setVarVisible(target->variableAt(index), true);
+        if (!target->isStage() && static_cast<Sprite *>(target)->isClone()) {
+            Sprite *sprite = static_cast<Sprite *>(target)->cloneSprite(); // use clone root variable
+            int index = sprite->findVariableById(vm->getInput(0, 1)->toString());
+            setVarVisible(sprite->variableAt(index), true, vm->engine());
+        } else {
+            int index = target->findVariableById(vm->getInput(0, 1)->toString());
+            setVarVisible(target->variableAt(index), true, vm->engine());
+        }
     }
 
     return 1;
@@ -119,7 +135,7 @@ unsigned int VariableBlocks::hideGlobalVariable(VirtualMachine *vm)
 {
     if (Stage *target = vm->engine()->stage()) {
         int index = target->findVariableById(vm->getInput(0, 1)->toString());
-        setVarVisible(target->variableAt(index), false);
+        setVarVisible(target->variableAt(index), false, vm->engine());
     }
 
     return 1;
@@ -128,8 +144,14 @@ unsigned int VariableBlocks::hideGlobalVariable(VirtualMachine *vm)
 unsigned int VariableBlocks::hideVariable(VirtualMachine *vm)
 {
     if (Target *target = vm->target()) {
-        int index = target->findVariableById(vm->getInput(0, 1)->toString());
-        setVarVisible(target->variableAt(index), false);
+        if (!target->isStage() && static_cast<Sprite *>(target)->isClone()) {
+            Sprite *sprite = static_cast<Sprite *>(target)->cloneSprite(); // use clone root variable
+            int index = sprite->findVariableById(vm->getInput(0, 1)->toString());
+            setVarVisible(sprite->variableAt(index), false, vm->engine());
+        } else {
+            int index = target->findVariableById(vm->getInput(0, 1)->toString());
+            setVarVisible(target->variableAt(index), false, vm->engine());
+        }
     }
 
     return 1;
diff --git a/src/blocks/variableblocks.h b/src/blocks/variableblocks.h
index 1d19a5be..2372660b 100644
--- a/src/blocks/variableblocks.h
+++ b/src/blocks/variableblocks.h
@@ -2,7 +2,8 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
+#include <memory>
 
 namespace libscratchcpp
 {
@@ -11,7 +12,7 @@ class Compiler;
 class Variable;
 
 /*! \brief The VariableBlocks class contains the implementation of variable blocks. */
-class VariableBlocks : public IBlockSection
+class VariableBlocks : public IExtension
 {
     public:
         enum Inputs
@@ -25,6 +26,7 @@ class VariableBlocks : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
 
@@ -34,7 +36,7 @@ class VariableBlocks : public IBlockSection
         static void compileShowVariable(Compiler *compiler);
         static void compileHideVariable(Compiler *compiler);
 
-        static void setVarVisible(std::shared_ptr<Variable> var, bool visible);
+        static void setVarVisible(std::shared_ptr<Variable> var, bool visible, IEngine *engine);
 
         static unsigned int showGlobalVariable(VirtualMachine *vm);
         static unsigned int showVariable(VirtualMachine *vm);
diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
index e7ee439a..755e771f 100644
--- a/src/engine/CMakeLists.txt
+++ b/src/engine/CMakeLists.txt
@@ -9,6 +9,9 @@ target_sources(scratchcpp
     script.cpp
     script_p.cpp
     script_p.h
+    thread.cpp
+    thread_p.cpp
+    thread_p.h
     internal/engine.cpp
     internal/engine.h
     internal/clock.cpp
@@ -16,8 +19,6 @@ target_sources(scratchcpp
     internal/iclock.h
     internal/timer.cpp
     internal/timer.h
-    internal/blocksectioncontainer.cpp
-    internal/blocksectioncontainer.h
     internal/randomgenerator.h
     internal/randomgenerator.cpp
     internal/irandomgenerator.h
diff --git a/src/engine/internal/blocksectioncontainer.cpp b/src/engine/internal/blocksectioncontainer.cpp
deleted file mode 100644
index aef43d5b..00000000
--- a/src/engine/internal/blocksectioncontainer.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-#include "blocksectioncontainer.h"
-
-using namespace libscratchcpp;
-
-static void dummyFunction(Compiler *compiler){};
-
-void BlockSectionContainer::addCompileFunction(const std::string &opcode, BlockComp f)
-{
-    m_compileFunctions[opcode] = f;
-}
-
-void BlockSectionContainer::addHatPredicateCompileFunction(const std::string &opcode, HatPredicateCompileFunc f)
-{
-    m_hatPredicateCompileFunctions[opcode] = f;
-}
-
-void BlockSectionContainer::addMonitorNameFunction(const std::string &opcode, MonitorNameFunc f)
-{
-    m_monitorNameFunctions[opcode] = f;
-}
-
-void BlockSectionContainer::addMonitorChangeFunction(const std::string &opcode, MonitorChangeFunc f)
-{
-    m_monitorChangeFunctions[opcode] = f;
-}
-
-void BlockSectionContainer::addHatBlock(const std::string &opcode)
-{
-    m_compileFunctions[opcode] = &dummyFunction;
-}
-
-void BlockSectionContainer::addInput(const std::string &name, int id)
-{
-    m_inputs[name] = id;
-}
-
-void BlockSectionContainer::addField(const std::string &name, int id)
-{
-    m_fields[name] = id;
-}
-
-void BlockSectionContainer::addFieldValue(const std::string &value, int id)
-{
-    m_fieldValues[value] = id;
-}
-
-BlockComp BlockSectionContainer::resolveBlockCompileFunc(const std::string &opcode) const
-{
-    if (m_compileFunctions.count(opcode) == 1)
-        return m_compileFunctions.at(opcode);
-    return nullptr;
-}
-
-HatPredicateCompileFunc BlockSectionContainer::resolveHatPredicateCompileFunc(const std::string &opcode) const
-{
-    if (m_hatPredicateCompileFunctions.count(opcode) == 1)
-        return m_hatPredicateCompileFunctions.at(opcode);
-    return nullptr;
-}
-
-MonitorNameFunc BlockSectionContainer::resolveMonitorNameFunc(const std::string &opcode) const
-{
-    if (m_monitorNameFunctions.count(opcode) == 1)
-        return m_monitorNameFunctions.at(opcode);
-    return nullptr;
-}
-
-MonitorChangeFunc BlockSectionContainer::resolveMonitorChangeFunc(const std::string &opcode) const
-{
-    if (m_monitorChangeFunctions.count(opcode) == 1)
-        return m_monitorChangeFunctions.at(opcode);
-    return nullptr;
-}
-
-int BlockSectionContainer::resolveInput(const std::string &name) const
-{
-    if (m_inputs.count(name) == 1)
-        return m_inputs.at(name);
-    return -1;
-}
-
-int BlockSectionContainer::resolveField(const std::string &name) const
-{
-    if (m_fields.count(name) == 1)
-        return m_fields.at(name);
-    return -1;
-}
-
-int BlockSectionContainer::resolveFieldValue(const std::string &value) const
-{
-    if (m_fieldValues.count(value) == 1)
-        return m_fieldValues.at(value);
-    return -1;
-}
diff --git a/src/engine/internal/blocksectioncontainer.h b/src/engine/internal/blocksectioncontainer.h
deleted file mode 100644
index 37026f3f..00000000
--- a/src/engine/internal/blocksectioncontainer.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-#pragma once
-
-#include <unordered_map>
-#include <string>
-#include <scratchcpp/global.h>
-
-namespace libscratchcpp
-{
-
-class BlockSectionContainer
-{
-    public:
-        BlockSectionContainer() = default;
-        BlockSectionContainer(const BlockSectionContainer &) = delete;
-
-        void addCompileFunction(const std::string &opcode, BlockComp f);
-        void addHatPredicateCompileFunction(const std::string &opcode, HatPredicateCompileFunc f);
-        void addMonitorNameFunction(const std::string &opcode, MonitorNameFunc f);
-        void addMonitorChangeFunction(const std::string &opcode, MonitorChangeFunc f);
-        void addHatBlock(const std::string &opcode);
-        void addInput(const std::string &name, int id);
-        void addField(const std::string &name, int id);
-        void addFieldValue(const std::string &value, int id);
-
-        BlockComp resolveBlockCompileFunc(const std::string &opcode) const;
-        HatPredicateCompileFunc resolveHatPredicateCompileFunc(const std::string &opcode) const;
-        MonitorNameFunc resolveMonitorNameFunc(const std::string &opcode) const;
-        MonitorChangeFunc resolveMonitorChangeFunc(const std::string &opcode) const;
-        int resolveInput(const std::string &name) const;
-        int resolveField(const std::string &name) const;
-        int resolveFieldValue(const std::string &value) const;
-
-    private:
-        std::unordered_map<std::string, BlockComp> m_compileFunctions;
-        std::unordered_map<std::string, HatPredicateCompileFunc> m_hatPredicateCompileFunctions;
-        std::unordered_map<std::string, MonitorNameFunc> m_monitorNameFunctions;
-        std::unordered_map<std::string, MonitorChangeFunc> m_monitorChangeFunctions;
-        std::unordered_map<std::string, int> m_inputs;
-        std::unordered_map<std::string, int> m_fields;
-        std::unordered_map<std::string, int> m_fieldValues;
-};
-
-} // namespace libscratchcpp
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 448103e4..6a15c9da 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/scratchconfiguration.h>
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 #include <scratchcpp/script.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
+#include <scratchcpp/textbubble.h>
 #include <scratchcpp/broadcast.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/input.h>
@@ -19,17 +20,15 @@
 #include <scratchcpp/sound.h>
 #include <scratchcpp/monitor.h>
 #include <scratchcpp/rect.h>
+#include <scratchcpp/thread.h>
 #include <cassert>
 #include <iostream>
 
 #include "engine.h"
-#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"
+#include "blocks/blocks.h"
 #include "scratch/monitor_p.h"
 
 using namespace libscratchcpp;
@@ -55,7 +54,7 @@ Engine::Engine() :
 Engine::~Engine()
 {
     m_clones.clear();
-    m_executableTargets.clear();
+    m_sortedDrawables.clear();
 }
 
 void Engine::clear()
@@ -66,17 +65,16 @@ void Engine::clear()
         m_monitorRemoved(monitor.get(), monitor->impl->iface);
 
     for (auto thread : m_threads) {
-        if (!thread->atEnd())
+        if (!thread->isFinished())
             m_threadAboutToStop(thread.get());
     }
 
-    m_sections.clear();
     m_targets.clear();
     m_broadcasts.clear();
     m_monitors.clear();
     m_extensions.clear();
     m_broadcastMap.clear();
-    m_executableTargets.clear();
+    m_sortedDrawables.clear();
     m_threads.clear();
     m_threadsToStop.clear();
     m_scripts.clear();
@@ -95,6 +93,7 @@ void Engine::clear()
     m_edgeActivatedHatValues.clear();
 
     m_running = false;
+    m_frameActivity = false;
 
     m_unsupportedBlocks.clear();
 }
@@ -106,21 +105,21 @@ void Engine::resolveIds()
         std::cout << "Processing target " << target->name() << "..." << std::endl;
         const auto &blocks = target->blocks();
         for (auto block : blocks) {
-            auto container = blockSectionContainer(block->opcode());
+            IExtension *ext = blockExtension(block->opcode());
             block->setNext(getBlock(block->nextId(), target.get()));
             block->setParent(getBlock(block->parentId(), target.get()));
 
-            if (container) {
-                block->setCompileFunction(container->resolveBlockCompileFunc(block->opcode()));
-                block->setHatPredicateCompileFunction(container->resolveHatPredicateCompileFunc(block->opcode()));
+            if (ext) {
+                block->setCompileFunction(resolveBlockCompileFunc(ext, block->opcode()));
+                block->setHatPredicateCompileFunction(resolveHatPredicateCompileFunc(ext, block->opcode()));
             }
 
             const auto &inputs = block->inputs();
             for (const auto &input : inputs) {
                 input->setValueBlock(getBlock(input->valueBlockId(), target.get()));
 
-                if (container)
-                    input->setInputId(container->resolveInput(input->name()));
+                if (ext)
+                    input->setInputId(resolveInput(ext, input->name()));
 
                 InputValue *value = input->primaryValue();
                 std::string id = value->valueId(); // no reference!
@@ -151,11 +150,11 @@ void Engine::resolveIds()
                 std::string id = field->valueId(); // no reference!
                 field->setValuePtr(getEntity(id, target.get()));
 
-                if (container) {
-                    field->setFieldId(container->resolveField(field->name()));
+                if (ext) {
+                    field->setFieldId(resolveField(ext, field->name()));
 
                     if (!field->valuePtr())
-                        field->setSpecialValueId(container->resolveFieldValue(field->value().toString()));
+                        field->setSpecialValueId(resolveFieldValue(ext, field->value().toString()));
                 }
 
                 // TODO: Move field information out of Engine
@@ -191,12 +190,12 @@ void Engine::resolveIds()
 
     for (auto monitor : m_monitors) {
         auto block = monitor->block();
-        auto container = blockSectionContainer(block->opcode());
+        auto ext = blockExtension(block->opcode());
 
-        if (container)
-            block->setCompileFunction(container->resolveBlockCompileFunc(block->opcode()));
+        if (ext)
+            block->setCompileFunction(resolveBlockCompileFunc(ext, block->opcode()));
 
-        monitor->setBlockSection(blockSection(monitor->opcode()));
+        monitor->setExtension(ext);
 
         const auto &fields = block->fields();
         Target *target;
@@ -211,11 +210,11 @@ void Engine::resolveIds()
         for (auto field : fields) {
             field->setValuePtr(getEntity(field->valueId(), target));
 
-            if (container) {
-                field->setFieldId(container->resolveField(field->name()));
+            if (ext) {
+                field->setFieldId(resolveField(ext, field->name()));
 
                 if (!field->valuePtr())
-                    field->setSpecialValueId(container->resolveFieldValue(field->value().toString()));
+                    field->setSpecialValueId(resolveFieldValue(ext, field->value().toString()));
             }
 
             // TODO: Move field information out of Engine
@@ -268,8 +267,8 @@ void Engine::compile()
         const auto &blocks = target->blocks();
         for (auto block : blocks) {
             if (block->topLevel() && !block->isTopLevelReporter() && !block->shadow()) {
-                auto section = blockSection(block->opcode());
-                if (section) {
+                auto ext = blockExtension(block->opcode());
+                if (ext) {
                     auto script = std::make_shared<Script>(target.get(), block, this);
                     m_scripts[block] = script;
 
@@ -312,56 +311,8 @@ void Engine::compile()
     // Compile monitor blocks to bytecode
     std::cout << "Compiling stage monitors..." << std::endl;
 
-    for (auto monitor : m_monitors) {
-        Target *target = monitor->sprite() ? dynamic_cast<Target *>(monitor->sprite()) : stage();
-        Compiler compiler(this, target);
-        auto block = monitor->block();
-        auto section = blockSection(block->opcode());
-        auto container = blockSectionContainer(block->opcode());
-
-        if (container) {
-            MonitorNameFunc nameFunc = container->resolveMonitorNameFunc(block->opcode());
-
-            if (nameFunc)
-                monitor->setName(nameFunc(block.get()));
-
-            MonitorChangeFunc changeFunc = container->resolveMonitorChangeFunc(block->opcode());
-            monitor->setValueChangeFunction(changeFunc);
-        }
-
-        if (section) {
-            auto script = std::make_shared<Script>(target, block, this);
-            monitor->setScript(script);
-            compiler.init();
-            compiler.setBlock(block);
-
-            if (block->compileFunction())
-                block->compile(&compiler);
-            else
-                std::cout << "warning: monitor block doesn't have a compile function: " << block->opcode() << std::endl;
-
-            // Workaround for register leak warning spam: pause the script after getting the monitor value
-            compiler.addFunctionCall([](VirtualMachine *vm) -> unsigned int {
-                vm->stop(false, false, false);
-                return 0;
-            });
-
-            compiler.end();
-
-            script->setBytecode(compiler.bytecode());
-            script->setConstValues(compiler.constValues());
-            script->setVariables(compiler.variables());
-            script->setLists(compiler.lists());
-        } 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);
-    }
+    for (auto monitor : m_monitors)
+        compileMonitor(monitor);
 }
 
 void Engine::start()
@@ -394,7 +345,7 @@ void Engine::stop()
             std::remove_if(
                 m_threads.begin(),
                 m_threads.end(),
-                [](std::shared_ptr<VirtualMachine> thread) {
+                [](std::shared_ptr<Thread> thread) {
                     assert(thread);
                     Target *target = thread->target();
                     assert(target);
@@ -413,7 +364,7 @@ void Engine::stop()
         // 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
         for (auto thread : m_threads) {
-            if (!thread->atEnd())
+            if (!thread->isFinished())
                 m_threadAboutToStop(thread.get());
         }
 
@@ -421,42 +372,45 @@ void Engine::stop()
         m_running = false;
     }
 
+    m_frameActivity = false;
     deleteClones();
     stopSounds();
     m_stopped();
 }
 
-VirtualMachine *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target *target)
+Thread *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target *target)
 {
     return pushThread(topLevelBlock, target).get();
 }
 
-void Engine::broadcast(int index)
+void Engine::broadcast(int index, Thread *sender, bool wait)
 {
     if (index < 0 || index >= m_broadcasts.size())
         return;
 
-    broadcastByPtr(m_broadcasts[index].get());
+    broadcastByPtr(m_broadcasts[index].get(), sender, wait);
 }
 
-void Engine::broadcastByPtr(Broadcast *broadcast)
+void Engine::broadcastByPtr(Broadcast *broadcast, Thread *sender, bool wait)
 {
     startHats(HatType::BroadcastReceived, { { HatField::BroadcastOption, broadcast } }, nullptr);
+    addBroadcastPromise(broadcast, sender, wait);
 }
 
-void Engine::startBackdropScripts(Broadcast *broadcast)
+void Engine::startBackdropScripts(Broadcast *broadcast, Thread *sender, bool wait)
 {
     startHats(HatType::BackdropChanged, { { HatField::Backdrop, broadcast->name() } }, nullptr);
+    addBroadcastPromise(broadcast, sender, wait);
 }
 
-void Engine::stopScript(VirtualMachine *vm)
+void Engine::stopScript(Thread *vm)
 {
     stopThread(vm);
 }
 
-void Engine::stopTarget(Target *target, VirtualMachine *exceptScript)
+void Engine::stopTarget(Target *target, Thread *exceptScript)
 {
-    std::vector<VirtualMachine *> threads;
+    std::vector<Thread *> threads;
 
     for (auto thread : m_threads) {
         if ((thread->target() == target) && (thread.get() != exceptScript))
@@ -481,21 +435,23 @@ void Engine::initClone(std::shared_ptr<Sprite> clone)
 #ifndef NDEBUG
     // Since we're initializing the clone, it shouldn't have any running scripts
     for (auto thread : m_threads)
-        assert(thread->target() != clone.get() || thread->atEnd());
+        assert(thread->target() != clone.get() || thread->isFinished());
 #endif
 
     startHats(HatType::CloneInit, {}, clone.get());
 
     assert(std::find(m_clones.begin(), m_clones.end(), clone) == m_clones.end());
-    assert(std::find(m_executableTargets.begin(), m_executableTargets.end(), clone.get()) == m_executableTargets.end());
+    assert(std::find(m_sortedDrawables.begin(), m_sortedDrawables.end(), clone.get()) == m_sortedDrawables.end());
     m_clones.insert(clone);
-    m_executableTargets.push_back(clone.get()); // execution order needs to be updated after this
+    m_sortedDrawables.push_back(clone.get()); // execution order needs to be updated after this
+    m_sortedDrawables.push_back(clone->bubble());
 }
 
 void Engine::deinitClone(std::shared_ptr<Sprite> clone)
 {
     m_clones.erase(clone);
-    m_executableTargets.erase(std::remove(m_executableTargets.begin(), m_executableTargets.end(), clone.get()), m_executableTargets.end());
+    m_sortedDrawables.erase(std::remove(m_sortedDrawables.begin(), m_sortedDrawables.end(), clone->bubble()), m_sortedDrawables.end());
+    m_sortedDrawables.erase(std::remove(m_sortedDrawables.begin(), m_sortedDrawables.end(), clone.get()), m_sortedDrawables.end());
 }
 
 void Engine::stopSounds()
@@ -526,9 +482,9 @@ void Engine::updateMonitors()
             auto script = monitor->script();
 
             if (script) {
-                auto vm = script->start();
-                vm->run();
-                monitor->updateValue(vm.get());
+                auto thread = script->start();
+                thread->run();
+                monitor->updateValue(thread->vm());
             }
         }
     }
@@ -540,7 +496,7 @@ void Engine::step()
     updateFrameDuration();
 
     // Clean up threads that were told to stop during or since the last step
-    m_threads.erase(std::remove_if(m_threads.begin(), m_threads.end(), [](std::shared_ptr<VirtualMachine> thread) { return thread->atEnd(); }), m_threads.end());
+    m_threads.erase(std::remove_if(m_threads.begin(), m_threads.end(), [](std::shared_ptr<Thread> thread) { return thread->isFinished(); }), m_threads.end());
 
     // Find all edge-activated hats, and add them to threads to be evaluated
     for (auto const &[hatType, edgeActivated] : m_hatEdgeActivated) {
@@ -578,6 +534,51 @@ void Engine::step()
         }
     }
 
+    // Check running threads (must be done here)
+    m_frameActivity = !m_threads.empty();
+
+    // Resolve stopped broadcast scripts
+    std::vector<Broadcast *> resolved;
+
+    for (const auto &[broadcast, senderThread] : m_broadcastSenders) {
+        std::unordered_map<Broadcast *, std::vector<Script *>> *broadcastMap = nullptr;
+
+        if (broadcast->isBackdropBroadcast()) {
+            // This broadcast belongs to a backdrop
+            assert(m_broadcastMap.find(broadcast) == m_broadcastMap.cend());
+            broadcastMap = &m_backdropBroadcastMap;
+        } else {
+            // This is a regular broadcast
+            assert(m_backdropBroadcastMap.find(broadcast) == m_backdropBroadcastMap.cend());
+            broadcastMap = &m_broadcastMap;
+        }
+
+        bool found = false;
+
+        if (broadcastMap->find(broadcast) != broadcastMap->cend()) {
+            const auto &scripts = (*broadcastMap)[broadcast];
+
+            for (auto script : scripts) {
+                if (std::find_if(m_threads.begin(), m_threads.end(), [script](std::shared_ptr<Thread> thread) { return thread->script() == script; }) != m_threads.end()) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+
+        if (!found) {
+            Thread *th = senderThread;
+
+            if (std::find_if(m_threads.begin(), m_threads.end(), [th](std::shared_ptr<Thread> thread) { return thread.get() == th; }) != m_threads.end())
+                th->resolvePromise();
+
+            resolved.push_back(broadcast);
+        }
+    }
+
+    for (Broadcast *broadcast : resolved)
+        m_broadcastSenders.erase(broadcast);
+
     m_redrawRequested = false;
 
     // Step threads
@@ -611,7 +612,7 @@ sigslot::signal<> &Engine::aboutToRender()
     return m_aboutToRedraw;
 }
 
-sigslot::signal<VirtualMachine *> &Engine::threadAboutToStop()
+sigslot::signal<Thread *> &Engine::threadAboutToStop()
 {
     return m_threadAboutToStop;
 }
@@ -621,7 +622,7 @@ sigslot::signal<> &Engine::stopped()
     return m_stopped;
 }
 
-std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
+std::vector<std::shared_ptr<Thread>> Engine::stepThreads()
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L70-L173
     const double WORK_TIME = 0.75 * m_frameDuration.count(); // 75% of frame duration
@@ -629,7 +630,7 @@ std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
     auto stepStart = m_clock->currentSteadyTime();
 
     size_t numActiveThreads = 1; // greater than zero
-    std::vector<std::shared_ptr<VirtualMachine>> doneThreads;
+    std::vector<std::shared_ptr<Thread>> doneThreads;
 
     auto elapsedTime = [this, &stepStart]() {
         std::chrono::steady_clock::time_point currentTime = m_clock->currentSteadyTime();
@@ -646,20 +647,20 @@ std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
             m_activeThread = m_threads[i];
 
             // Check if the thread is done so it is not executed
-            if (m_activeThread->atEnd()) {
+            if (m_activeThread->isFinished()) {
                 // Finished with this thread
                 continue;
             }
 
             stepThread(m_activeThread);
 
-            if (!m_activeThread->atEnd())
+            if (!m_activeThread->isFinished())
                 numActiveThreads++;
         }
 
         // Remove threads in m_threadsToStop
         for (auto thread : m_threadsToStop) {
-            if (!thread->atEnd())
+            if (!thread->isFinished())
                 m_threadAboutToStop(thread.get());
 
             m_threads.erase(std::remove(m_threads.begin(), m_threads.end(), thread), m_threads.end());
@@ -672,8 +673,8 @@ std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
             std::remove_if(
                 m_threads.begin(),
                 m_threads.end(),
-                [&doneThreads](std::shared_ptr<VirtualMachine> thread) {
-                    if (thread->atEnd()) {
+                [&doneThreads](std::shared_ptr<Thread> thread) {
+                    if (thread->isFinished()) {
                         doneThreads.push_back(thread);
                         return true;
                     } else
@@ -689,7 +690,7 @@ std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
     return doneThreads;
 }
 
-void Engine::stepThread(std::shared_ptr<VirtualMachine> thread)
+void Engine::stepThread(std::shared_ptr<Thread> thread)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L179-L276
     thread->run();
@@ -737,7 +738,7 @@ void Engine::eventLoop(bool untilProjectStops)
 
 bool Engine::isRunning() const
 {
-    return m_running;
+    return m_running || m_frameActivity;
 }
 
 double Engine::fps() const
@@ -911,57 +912,6 @@ void Engine::setSpriteFencingEnabled(bool enable)
     m_spriteFencingEnabled = enable;
 }
 
-bool Engine::broadcastRunning(unsigned int index)
-{
-    if (index < 0 || index >= m_broadcasts.size())
-        return false;
-
-    return broadcastByPtrRunning(m_broadcasts[index].get());
-}
-
-bool Engine::broadcastByPtrRunning(Broadcast *broadcast)
-{
-    if (broadcast->isBackdropBroadcast()) {
-        // This broadcast belongs to a backdrop
-        assert(m_broadcastMap.find(broadcast) == m_broadcastMap.cend());
-
-        for (auto thread : m_threads) {
-            if (!thread->atEnd()) {
-                Script *script = thread->script();
-                auto topBlock = script->topBlock();
-
-                const auto &scripts = m_backdropChangeHats[script->target()];
-                auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
-                auto scriptFieldMapIt = m_scriptHatFields.find(script);
-
-                if (scriptFieldMapIt != m_scriptHatFields.cend()) {
-                    const auto &fieldMap = scriptFieldMapIt->second;
-                    auto fieldIt = fieldMap.find(HatField::Backdrop);
-                    assert(fieldIt != fieldMap.cend());
-                    assert(topBlock->findFieldById(fieldIt->second));
-
-                    if ((scriptIt != scripts.end()) && (topBlock->findFieldById(fieldIt->second)->value().toString() == broadcast->name()))
-                        return true;
-                }
-            }
-        }
-    } else {
-        // This is a regular broadcast
-        assert(m_broadcastMap.find(broadcast) != m_broadcastMap.cend());
-        const auto &scripts = m_broadcastMap[broadcast];
-
-        for (auto thread : m_threads) {
-            if (!thread->atEnd()) {
-                auto it = std::find_if(scripts.begin(), scripts.end(), [thread](Script *script) { return thread->script() == script; });
-
-                if (it != scripts.end())
-                    return true;
-            }
-        }
-    }
-    return false;
-}
-
 void Engine::requestRedraw()
 {
     m_redrawRequested = true;
@@ -977,30 +927,6 @@ void Engine::setTimer(ITimer *timer)
     m_timer = timer;
 }
 
-void Engine::registerSection(std::shared_ptr<IBlockSection> section)
-{
-    if (section) {
-        if (m_sections.find(section) != m_sections.cend()) {
-            std::cerr << "Warning: block section \"" << section->name() << "\" is already registered" << std::endl;
-            return;
-        }
-
-        m_sections[section] = std::make_unique<BlockSectionContainer>();
-        section->registerBlocks(this);
-        section->onInit(this);
-    }
-}
-
-std::vector<std::shared_ptr<IBlockSection>> Engine::registeredSections() const
-{
-    std::vector<std::shared_ptr<IBlockSection>> ret;
-
-    for (const auto &[key, value] : m_sections)
-        ret.push_back(key);
-
-    return ret;
-}
-
 unsigned int Engine::functionIndex(BlockFunc f)
 {
     auto it = std::find(m_functions.begin(), m_functions.end(), f);
@@ -1015,68 +941,68 @@ const std::vector<BlockFunc> &Engine::blockFunctions() const
     return m_functions;
 }
 
-void Engine::addCompileFunction(IBlockSection *section, const std::string &opcode, BlockComp f)
+void Engine::addCompileFunction(IExtension *extension, const std::string &opcode, BlockComp f)
 {
-    auto container = blockSectionContainer(section);
+    if (m_compileFunctions.find(extension) == m_compileFunctions.cend())
+        m_compileFunctions[extension] = {};
 
-    if (container)
-        container->addCompileFunction(opcode, f);
+    m_compileFunctions[extension][opcode] = f;
 }
 
-void Engine::addHatPredicateCompileFunction(IBlockSection *section, const std::string &opcode, HatPredicateCompileFunc f)
+void Engine::addHatPredicateCompileFunction(IExtension *extension, const std::string &opcode, HatPredicateCompileFunc f)
 {
-    auto container = blockSectionContainer(section);
+    if (m_hatPredicateCompileFunctions.find(extension) == m_hatPredicateCompileFunctions.cend())
+        m_hatPredicateCompileFunctions[extension] = {};
 
-    if (container)
-        container->addHatPredicateCompileFunction(opcode, f);
+    m_hatPredicateCompileFunctions[extension][opcode] = f;
 }
 
-void Engine::addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f)
+void Engine::addMonitorNameFunction(IExtension *extension, const std::string &opcode, MonitorNameFunc f)
 {
-    auto container = blockSectionContainer(section);
+    if (m_monitorNameFunctions.find(extension) == m_monitorNameFunctions.cend())
+        m_monitorNameFunctions[extension] = {};
 
-    if (container)
-        container->addMonitorNameFunction(opcode, f);
+    m_monitorNameFunctions[extension][opcode] = f;
 }
 
-void Engine::addMonitorChangeFunction(IBlockSection *section, const std::string &opcode, MonitorChangeFunc f)
+void Engine::addMonitorChangeFunction(IExtension *extension, const std::string &opcode, MonitorChangeFunc f)
 {
-    auto container = blockSectionContainer(section);
+    if (m_monitorChangeFunctions.find(extension) == m_monitorChangeFunctions.cend())
+        m_monitorChangeFunctions[extension] = {};
 
-    if (container)
-        container->addMonitorChangeFunction(opcode, f);
+    m_monitorChangeFunctions[extension][opcode] = f;
 }
 
-void Engine::addHatBlock(IBlockSection *section, const std::string &opcode)
+void Engine::addHatBlock(IExtension *extension, const std::string &opcode)
 {
-    auto container = blockSectionContainer(section);
+    if (m_compileFunctions.find(extension) == m_compileFunctions.cend())
+        m_compileFunctions[extension] = {};
 
-    if (container)
-        container->addHatBlock(opcode);
+    m_compileFunctions[extension][opcode] = [](Compiler *compiler) {};
 }
 
-void Engine::addInput(IBlockSection *section, const std::string &name, int id)
+void Engine::addInput(IExtension *extension, const std::string &name, int id)
 {
-    auto container = blockSectionContainer(section);
+    if (m_inputs.find(extension) == m_inputs.cend())
+        m_inputs[extension] = {};
 
-    if (container)
-        container->addInput(name, id);
+    m_inputs[extension][name] = id;
 }
 
-void Engine::addField(IBlockSection *section, const std::string &name, int id)
+void Engine::addField(IExtension *extension, const std::string &name, int id)
 {
-    auto container = blockSectionContainer(section);
+    if (m_fields.find(extension) == m_fields.cend())
+        m_fields[extension] = {};
 
-    if (container)
-        container->addField(name, id);
+    m_fields[extension][name] = id;
 }
 
-void Engine::addFieldValue(IBlockSection *section, const std::string &value, int id)
+void Engine::addFieldValue(IExtension *extension, const std::string &value, int id)
 {
-    auto container = blockSectionContainer(section);
+    if (m_fieldValues.find(extension) == m_fieldValues.cend())
+        m_fieldValues[extension] = {};
 
-    if (container)
-        container->addFieldValue(value, id);
+    m_fieldValues[extension][value] = id;
 }
 
 const std::vector<std::shared_ptr<Broadcast>> &Engine::broadcasts() const
@@ -1134,7 +1060,7 @@ void Engine::addGreenFlagScript(std::shared_ptr<Block> hatBlock)
     addHatToMap(m_greenFlagHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast)
+void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Field *field, Broadcast *broadcast)
 {
     assert(!broadcast->isBackdropBroadcast());
     Script *script = m_scripts[whenReceivedBlock].get();
@@ -1150,14 +1076,44 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fi
         m_broadcastMap[broadcast] = { script };
 
     addHatToMap(m_broadcastHats, script);
-    addHatField(script, HatField::BroadcastOption, fieldId);
+    addHatField(script, HatField::BroadcastOption, field);
 }
 
-void Engine::addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId)
+void Engine::addBackdropChangeScript(std::shared_ptr<Block> hatBlock, Field *field)
 {
+    Stage *stage = this->stage();
+
+    if (!stage)
+        return;
+
+    if (!field) {
+        assert(false);
+        return;
+    }
+
+    const std::string &backdropName = field->value().toString();
+    auto backdrop = stage->costumeAt(stage->findCostume(backdropName));
+
+    if (!backdrop)
+        return;
+
+    Broadcast *broadcast = backdrop->broadcast();
+    assert(broadcast->isBackdropBroadcast());
+
     Script *script = m_scripts[hatBlock].get();
+    auto it = m_backdropBroadcastMap.find(broadcast);
+
+    if (it != m_backdropBroadcastMap.cend()) {
+        auto &scripts = it->second;
+        auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
+
+        if (scriptIt == scripts.end())
+            scripts.push_back(script);
+    } else
+        m_backdropBroadcastMap[broadcast] = { script };
+
     addHatToMap(m_backdropChangeHats, script);
-    addHatField(script, HatField::Backdrop, fieldId);
+    addHatField(script, HatField::Backdrop, field);
 }
 
 void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
@@ -1165,11 +1121,11 @@ void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
     addHatToMap(m_cloneInitHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId)
+void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, Field *field)
 {
     Script *script = m_scripts[hatBlock].get();
     addHatToMap(m_whenKeyPressedHats, script);
-    addHatField(script, HatField::KeyOption, fieldId);
+    addHatField(script, HatField::KeyOption, field);
 }
 
 void Engine::addTargetClickScript(std::shared_ptr<Block> hatBlock)
@@ -1191,10 +1147,10 @@ const std::vector<std::shared_ptr<Target>> &Engine::targets() const
 void Engine::setTargets(const std::vector<std::shared_ptr<Target>> &newTargets)
 {
     m_targets = newTargets;
-    m_executableTargets.clear();
+    m_sortedDrawables.clear();
 
     for (auto target : m_targets) {
-        m_executableTargets.push_back(target.get());
+        m_sortedDrawables.push_back(target.get());
 
         // Set engine in the target
         target->setEngine(this);
@@ -1207,11 +1163,14 @@ void Engine::setTargets(const std::vector<std::shared_ptr<Target>> &newTargets)
         }
     }
 
-    // Sort the executable targets by layer order
-    std::sort(m_executableTargets.begin(), m_executableTargets.end(), [](Target *t1, Target *t2) { return t1->layerOrder() < t2->layerOrder(); });
+    // Sort the targets by layer order
+    std::sort(m_sortedDrawables.begin(), m_sortedDrawables.end(), [](Drawable *d1, Drawable *d2) { return d1->layerOrder() < d2->layerOrder(); });
 
-    // Create missing monitors
-    createMissingMonitors();
+    // Add text bubbles (layers are irrelevant until text is displayed)
+    for (auto target : m_targets) {
+        target->bubble()->setLayerOrder(m_sortedDrawables.size());
+        m_sortedDrawables.push_back(target->bubble());
+    }
 }
 
 Target *Engine::targetAt(int index) const
@@ -1222,6 +1181,33 @@ Target *Engine::targetAt(int index) const
     return m_targets[index].get();
 }
 
+void Engine::getVisibleTargets(std::vector<Target *> &dst) const
+{
+    dst.clear();
+
+    for (auto target : m_targets) {
+        assert(target);
+
+        if (target->isStage())
+            dst.push_back(target.get());
+        else {
+            Sprite *sprite = static_cast<Sprite *>(target.get());
+
+            if (sprite->visible())
+                dst.push_back(target.get());
+
+            const auto &clones = sprite->clones();
+
+            for (auto clone : clones) {
+                if (clone->visible())
+                    dst.push_back(clone.get());
+            }
+        }
+    }
+
+    std::sort(dst.begin(), dst.end(), [](Target *t1, Target *t2) { return t1->layerOrder() > t2->layerOrder(); });
+}
+
 int Engine::findTarget(const std::string &targetName) const
 {
     auto it = std::find_if(m_targets.begin(), m_targets.end(), [targetName](std::shared_ptr<Target> target) {
@@ -1234,51 +1220,63 @@ int Engine::findTarget(const std::string &targetName) const
         return it - m_targets.begin();
 }
 
-void Engine::moveSpriteToFront(Sprite *sprite)
+void Engine::moveDrawableToFront(Drawable *drawable)
 {
-    if (!sprite || m_executableTargets.size() <= 2)
+    if (!drawable || m_sortedDrawables.size() <= 2)
+        return;
+
+    if (drawable->isTarget() && static_cast<Target *>(drawable)->isStage()) {
+        std::cout << "warning: cannot move stage to front" << std::endl;
+        assert(false);
         return;
+    }
 
-    auto it = std::find(m_executableTargets.begin(), m_executableTargets.end(), sprite);
+    auto it = std::find(m_sortedDrawables.begin(), m_sortedDrawables.end(), drawable);
 
-    if (it != m_executableTargets.end()) {
-        std::rotate(it, it + 1, m_executableTargets.end());
-        updateSpriteLayerOrder();
+    if (it != m_sortedDrawables.end()) {
+        std::rotate(it, it + 1, m_sortedDrawables.end());
+        updateDrawableLayerOrder();
     }
 }
 
-void Engine::moveSpriteToBack(Sprite *sprite)
+void Engine::moveDrawableToBack(Drawable *drawable)
 {
-    if (!sprite || m_executableTargets.size() <= 2)
+    if (!drawable || m_sortedDrawables.size() <= 2)
         return;
 
-    auto it = std::find(m_executableTargets.begin(), m_executableTargets.end(), sprite);
+    auto it = std::find(m_sortedDrawables.begin(), m_sortedDrawables.end(), drawable);
 
-    if (it != m_executableTargets.end()) {
-        std::rotate(m_executableTargets.begin() + 1, it, it + 1); // stage is always the first
-        updateSpriteLayerOrder();
+    if (it != m_sortedDrawables.end()) {
+        std::rotate(m_sortedDrawables.begin() + 1, it, it + 1); // stage is always the first
+        updateDrawableLayerOrder();
     }
 }
 
-void Engine::moveSpriteForwardLayers(Sprite *sprite, int layers)
+void Engine::moveDrawableForwardLayers(Drawable *drawable, int layers)
 {
-    if (!sprite || layers == 0)
+    if (!drawable || layers == 0)
+        return;
+
+    if (layers > 0 && drawable->isTarget() && static_cast<Target *>(drawable)->isStage()) {
+        std::cout << "warning: cannot move stage forward" << std::endl;
+        assert(false);
         return;
+    }
 
-    auto it = std::find(m_executableTargets.begin(), m_executableTargets.end(), sprite);
+    auto it = std::find(m_sortedDrawables.begin(), m_sortedDrawables.end(), drawable);
 
-    if (it == m_executableTargets.end())
+    if (it == m_sortedDrawables.end())
         return;
 
     auto target = it + layers;
 
-    if (target <= m_executableTargets.begin()) {
-        moveSpriteToBack(sprite);
+    if (target <= m_sortedDrawables.begin()) {
+        moveDrawableToBack(drawable);
         return;
     }
 
-    if (target >= m_executableTargets.end()) {
-        moveSpriteToFront(sprite);
+    if (target >= m_sortedDrawables.end()) {
+        moveDrawableToFront(drawable);
         return;
     }
 
@@ -1287,23 +1285,29 @@ void Engine::moveSpriteForwardLayers(Sprite *sprite, int layers)
     else
         std::rotate(target, it, it + 1);
 
-    updateSpriteLayerOrder();
+    updateDrawableLayerOrder();
 }
 
-void Engine::moveSpriteBackwardLayers(Sprite *sprite, int layers)
+void Engine::moveDrawableBackwardLayers(Drawable *drawable, int layers)
 {
-    moveSpriteForwardLayers(sprite, -layers);
+    moveDrawableForwardLayers(drawable, -layers);
 }
 
-void Engine::moveSpriteBehindOther(Sprite *sprite, Sprite *other)
+void Engine::moveDrawableBehindOther(Drawable *drawable, Drawable *other)
 {
-    if (sprite == other)
+    if (drawable == other)
+        return;
+
+    if (drawable->isTarget() && static_cast<Target *>(drawable)->isStage()) {
+        std::cout << "warning: cannot move stage behind drawable" << std::endl;
+        assert(false);
         return;
+    }
 
-    auto itSprite = std::find(m_executableTargets.begin(), m_executableTargets.end(), sprite);
-    auto itOther = std::find(m_executableTargets.begin(), m_executableTargets.end(), other);
+    auto itSprite = std::find(m_sortedDrawables.begin(), m_sortedDrawables.end(), drawable);
+    auto itOther = std::find(m_sortedDrawables.begin(), m_sortedDrawables.end(), other);
 
-    if ((itSprite == m_executableTargets.end()) || (itOther == m_executableTargets.end()))
+    if ((itSprite == m_sortedDrawables.end()) || (itOther == m_sortedDrawables.end()))
         return;
 
     auto target = itOther - 1; // behind
@@ -1311,13 +1315,13 @@ void Engine::moveSpriteBehindOther(Sprite *sprite, Sprite *other)
     if (target < itSprite)
         target++;
 
-    if (target <= m_executableTargets.begin()) {
-        moveSpriteToBack(sprite);
+    if (target <= m_sortedDrawables.begin()) {
+        moveDrawableToBack(drawable);
         return;
     }
 
-    if (target >= m_executableTargets.end()) {
-        moveSpriteToFront(sprite);
+    if (target >= m_sortedDrawables.end()) {
+        moveDrawableToFront(drawable);
         return;
     }
 
@@ -1326,7 +1330,7 @@ void Engine::moveSpriteBehindOther(Sprite *sprite, Sprite *other)
     else
         std::rotate(target, itSprite, itSprite + 1);
 
-    updateSpriteLayerOrder();
+    updateDrawableLayerOrder();
 }
 
 Stage *Engine::stage() const
@@ -1336,7 +1340,7 @@ Stage *Engine::stage() const
     if (it == m_targets.end())
         return nullptr;
     else
-        return dynamic_cast<Stage *>((*it).get());
+        return static_cast<Stage *>((*it).get());
 }
 
 const std::vector<std::shared_ptr<Monitor>> &Engine::monitors() const
@@ -1352,9 +1356,43 @@ void Engine::setMonitors(const std::vector<std::shared_ptr<Monitor>> &newMonitor
         m_monitors.push_back(monitor);
         m_monitorAdded(monitor.get());
     }
+}
+
+Monitor *Engine::createVariableMonitor(std::shared_ptr<Variable> var, const std::string &opcode, const std::string &varFieldName, int varFieldId, BlockComp compileFunction)
+{
+    if (var->monitor())
+        return var->monitor();
+    else {
+        auto monitor = std::make_shared<Monitor>(var->id(), opcode);
+        auto field = std::make_shared<Field>(varFieldName, var->name(), var);
+        field->setFieldId(varFieldId);
+        monitor->block()->addField(field);
+        monitor->block()->setCompileFunction(compileFunction);
+
+        addVarOrListMonitor(monitor, var->target());
+        var->setMonitor(monitor.get());
+        compileMonitor(monitor);
+        return monitor.get();
+    }
+}
 
-    // Create missing monitors
-    createMissingMonitors();
+Monitor *Engine::createListMonitor(std::shared_ptr<List> list, const std::string &opcode, const std::string &listFieldName, int listFieldId, BlockComp compileFunction)
+{
+    if (list->monitor())
+        return list->monitor();
+    else {
+        auto monitor = std::make_shared<Monitor>(list->id(), opcode);
+        auto field = std::make_shared<Field>(listFieldName, list->name(), list);
+        field->setFieldId(listFieldId);
+        monitor->block()->addField(field);
+        monitor->block()->setCompileFunction(compileFunction);
+        monitor->setMode(Monitor::Mode::List);
+
+        addVarOrListMonitor(monitor, list->target());
+        list->setMonitor(monitor.get());
+        compileMonitor(monitor);
+        return monitor.get();
+    }
 }
 
 sigslot::signal<Monitor *> &Engine::monitorAdded()
@@ -1389,18 +1427,22 @@ const std::vector<std::string> &Engine::extensions() const
 
 void Engine::setExtensions(const std::vector<std::string> &newExtensions)
 {
-    m_sections.clear();
+    clearExtensionData();
     m_extensions = newExtensions;
 
-    // Register standard block sections
-    ScratchConfiguration::getExtension<StandardBlocks>()->registerSections(this);
+    // Register blocks of default extensions
+    const auto &defaultExtensions = Blocks::extensions();
+
+    for (auto ext : defaultExtensions)
+        ext->registerBlocks(this);
 
-    // Register block sections of extensions
+    // Register blocks of custom extensions
     for (auto ext : m_extensions) {
         IExtension *ptr = ScratchConfiguration::getExtension(ext);
-        if (ptr)
-            ptr->registerSections(this);
-        else
+        if (ptr) {
+            ptr->registerBlocks(this);
+            ptr->onInit(this);
+        } else
             std::cerr << "Unsupported extension: " << ext << std::endl;
     }
 }
@@ -1576,17 +1618,6 @@ std::shared_ptr<Entity> Engine::getEntity(const std::string &id, Target *target)
     return nullptr;
 }
 
-std::shared_ptr<IBlockSection> Engine::blockSection(const std::string &opcode) const
-{
-    for (const auto &pair : m_sections) {
-        auto block = pair.second->resolveBlockCompileFunc(opcode);
-        if (block)
-            return pair.first;
-    }
-
-    return nullptr;
-}
-
 void Engine::addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script)
 {
     if (!script)
@@ -1606,15 +1637,15 @@ void Engine::addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &ma
         map[target] = { script };
 }
 
-void Engine::addHatField(Script *script, HatField field, int fieldId)
+void Engine::addHatField(Script *script, HatField hatField, Field *targetField)
 {
     auto it = m_scriptHatFields.find(script);
 
     if (it == m_scriptHatFields.cend())
-        m_scriptHatFields[script] = { { field, fieldId } };
+        m_scriptHatFields[script] = { { hatField, targetField } };
     else {
         auto &fieldMap = it->second;
-        fieldMap[field] = fieldId;
+        fieldMap[hatField] = targetField;
     }
 }
 
@@ -1624,8 +1655,7 @@ const std::vector<Script *> &Engine::getHats(Target *target, HatType type)
 
     // Get root if this is a clone
     if (!target->isStage()) {
-        Sprite *sprite = dynamic_cast<Sprite *>(target);
-        assert(sprite);
+        Sprite *sprite = static_cast<Sprite *>(target);
 
         if (sprite->isClone())
             target = sprite->cloneSprite();
@@ -1663,51 +1693,218 @@ const std::vector<Script *> &Engine::getHats(Target *target, HatType type)
     }
 }
 
-void Engine::updateSpriteLayerOrder()
+void Engine::updateDrawableLayerOrder()
 {
-    assert(m_executableTargets.empty() || m_executableTargets[0]->isStage());
+    assert(m_sortedDrawables.empty() || (m_sortedDrawables[0]->isTarget() && static_cast<Target *>(m_sortedDrawables[0])->isStage()));
 
-    for (size_t i = 1; i < m_executableTargets.size(); i++) // i = 1 to skip the stage
-        m_executableTargets[i]->setLayerOrder(i);
+    for (size_t i = 1; i < m_sortedDrawables.size(); i++) // i = 1 to skip the stage
+        m_sortedDrawables[i]->setLayerOrder(i);
 }
 
-BlockSectionContainer *Engine::blockSectionContainer(const std::string &opcode) const
+const std::string &Engine::userAgent() const
 {
-    for (const auto &pair : m_sections) {
-        auto block = pair.second->resolveBlockCompileFunc(opcode);
-        if (block)
-            return pair.second.get();
+    return m_userAgent;
+}
+
+void Engine::setUserAgent(const std::string &agent)
+{
+    m_userAgent = agent;
+}
+
+const std::unordered_set<std::string> &Engine::unsupportedBlocks() const
+{
+    return m_unsupportedBlocks;
+}
+
+void Engine::clearExtensionData()
+{
+    m_compileFunctions.clear();
+    m_hatPredicateCompileFunctions.clear();
+    m_monitorNameFunctions.clear();
+    m_monitorChangeFunctions.clear();
+    m_inputs.clear();
+    m_fields.clear();
+    m_fieldValues.clear();
+}
+
+IExtension *Engine::blockExtension(const std::string &opcode) const
+{
+    for (const auto &[ext, data] : m_compileFunctions) {
+        auto it = data.find(opcode);
+
+        if (it != data.cend())
+            return ext;
     }
 
     return nullptr;
 }
 
-BlockSectionContainer *Engine::blockSectionContainer(IBlockSection *section) const
+BlockComp Engine::resolveBlockCompileFunc(IExtension *extension, const std::string &opcode) const
 {
-    if (!section)
+    if (!extension)
         return nullptr;
 
-    for (const auto &pair : m_sections) {
-        if (pair.first.get() == section)
-            return pair.second.get();
+    auto it = m_compileFunctions.find(extension);
+
+    if (it != m_compileFunctions.cend()) {
+        auto dataIt = it->second.find(opcode);
+
+        if (dataIt != it->second.cend())
+            return dataIt->second;
     }
 
     return nullptr;
 }
 
-const std::string &Engine::userAgent() const
+HatPredicateCompileFunc Engine::resolveHatPredicateCompileFunc(IExtension *extension, const std::string &opcode) const
 {
-    return m_userAgent;
+    if (!extension)
+        return nullptr;
+
+    auto it = m_hatPredicateCompileFunctions.find(extension);
+
+    if (it != m_hatPredicateCompileFunctions.cend()) {
+        auto dataIt = it->second.find(opcode);
+
+        if (dataIt != it->second.cend())
+            return dataIt->second;
+    }
+
+    return nullptr;
 }
 
-void Engine::setUserAgent(const std::string &agent)
+MonitorNameFunc Engine::resolveMonitorNameFunc(IExtension *extension, const std::string &opcode) const
 {
-    m_userAgent = agent;
+    if (!extension)
+        return nullptr;
+
+    auto it = m_monitorNameFunctions.find(extension);
+
+    if (it != m_monitorNameFunctions.cend()) {
+        auto dataIt = it->second.find(opcode);
+
+        if (dataIt != it->second.cend())
+            return dataIt->second;
+    }
+
+    return nullptr;
 }
 
-const std::unordered_set<std::string> &Engine::unsupportedBlocks() const
+MonitorChangeFunc Engine::resolveMonitorChangeFunc(IExtension *extension, const std::string &opcode) const
 {
-    return m_unsupportedBlocks;
+    if (!extension)
+        return nullptr;
+
+    auto it = m_monitorChangeFunctions.find(extension);
+
+    if (it != m_monitorChangeFunctions.cend()) {
+        auto dataIt = it->second.find(opcode);
+
+        if (dataIt != it->second.cend())
+            return dataIt->second;
+    }
+
+    return nullptr;
+}
+
+int Engine::resolveInput(IExtension *extension, const std::string &name) const
+{
+    if (!extension)
+        return -1;
+
+    auto it = m_inputs.find(extension);
+
+    if (it != m_inputs.cend()) {
+        auto dataIt = it->second.find(name);
+
+        if (dataIt != it->second.cend())
+            return dataIt->second;
+    }
+
+    return -1;
+}
+
+int Engine::resolveField(IExtension *extension, const std::string &name) const
+{
+    if (!extension)
+        return -1;
+
+    auto it = m_fields.find(extension);
+
+    if (it != m_fields.cend()) {
+        auto dataIt = it->second.find(name);
+
+        if (dataIt != it->second.cend())
+            return dataIt->second;
+    }
+
+    return -1;
+}
+
+int Engine::resolveFieldValue(IExtension *extension, const std::string &value) const
+{
+    if (!extension)
+        return -1;
+
+    auto it = m_fieldValues.find(extension);
+
+    if (it != m_fieldValues.cend()) {
+        auto dataIt = it->second.find(value);
+
+        if (dataIt != it->second.cend())
+            return dataIt->second;
+    }
+
+    return -1;
+}
+
+void Engine::compileMonitor(std::shared_ptr<Monitor> monitor)
+{
+    Target *target = monitor->sprite() ? static_cast<Target *>(monitor->sprite()) : stage();
+    Compiler compiler(this, target);
+    auto block = monitor->block();
+    auto ext = blockExtension(block->opcode());
+
+    if (ext) {
+        MonitorNameFunc nameFunc = resolveMonitorNameFunc(ext, block->opcode());
+
+        if (nameFunc)
+            monitor->setName(nameFunc(block.get()));
+
+        MonitorChangeFunc changeFunc = resolveMonitorChangeFunc(ext, block->opcode());
+        monitor->setValueChangeFunction(changeFunc);
+
+        auto script = std::make_shared<Script>(target, block, this);
+        monitor->setScript(script);
+        compiler.init();
+        compiler.setBlock(block);
+
+        if (block->compileFunction())
+            block->compile(&compiler);
+        else
+            std::cout << "warning: monitor block doesn't have a compile function: " << block->opcode() << std::endl;
+
+        // Workaround for register leak warning spam: pause the script after getting the monitor value
+        compiler.addFunctionCall([](VirtualMachine *vm) -> unsigned int {
+            vm->stop(false, false, false);
+            return 0;
+        });
+
+        compiler.end();
+
+        script->setBytecode(compiler.bytecode());
+        script->setConstValues(compiler.constValues());
+        script->setVariables(compiler.variables());
+        script->setLists(compiler.lists());
+    } 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);
 }
 
 void Engine::finalize()
@@ -1726,9 +1923,8 @@ void Engine::deleteClones()
     m_clones.clear();
 
     for (auto target : m_targets) {
-        Sprite *sprite = dynamic_cast<Sprite *>(target.get());
-
-        if (sprite) {
+        if (!target->isStage()) {
+            Sprite *sprite = static_cast<Sprite *>(target.get());
             std::vector<std::shared_ptr<Sprite>> clones = sprite->clones();
 
             for (auto clone : clones) {
@@ -1743,88 +1939,29 @@ void Engine::deleteClones()
 
 void Engine::removeExecutableClones()
 {
-    // Remove clones from the executable targets
+    // Remove clones from sorted drawables
     for (std::shared_ptr<Sprite> clone : m_clones)
-        m_executableTargets.erase(std::remove(m_executableTargets.begin(), m_executableTargets.end(), clone.get()), m_executableTargets.end());
-}
-
-void Engine::createMissingMonitors()
-{
-    // This is called when setting targets and monitors because we never know in which order they're set
-    // If there aren't any targets yet, quit
-    if (m_targets.empty())
-        return;
-
-    for (auto target : m_targets) {
-        // Read all variables
-        const auto &variables = target->variables();
-
-        for (auto variable : variables) {
-            // Find the monitor for this variable
-            auto it = std::find_if(m_monitors.begin(), m_monitors.end(), [variable](std::shared_ptr<Monitor> monitor) {
-                // TODO: Move the opcode out of Engine
-                return monitor->opcode() == "data_variable" && monitor->id() == variable->id();
-            });
-
-            // If it doesn't exist, create it
-            if (it == m_monitors.end()) {
-                auto monitor = std::make_shared<Monitor>(variable->id(), "data_variable");
-                // TODO: Move field information out of Engine
-                auto field = std::make_shared<Field>("VARIABLE", variable->name(), variable);
-                field->setFieldId(VariableBlocks::VARIABLE);
-                monitor->block()->addField(field);
-
-                addVarOrListMonitor(monitor, target.get());
-            }
-        }
-
-        // Read all lists
-        const auto &lists = target->lists();
-
-        for (auto list : lists) {
-            // Find the monitor for this list
-            auto it = std::find_if(m_monitors.begin(), m_monitors.end(), [list](std::shared_ptr<Monitor> monitor) {
-                // TODO: Move the opcode out of Engine
-                return monitor->opcode() == "data_listcontents" && monitor->id() == list->id();
-            });
-
-            // If it doesn't exist, create it
-            if (it == m_monitors.end()) {
-                auto monitor = std::make_shared<Monitor>(list->id(), "data_listcontents");
-                // TODO: Move field information out of Engine
-                auto field = std::make_shared<Field>("LIST", list->name(), list);
-                field->setFieldId(ListBlocks::LIST);
-                monitor->block()->addField(field);
-
-                addVarOrListMonitor(monitor, target.get());
-            }
-        }
-    }
+        m_sortedDrawables.erase(std::remove(m_sortedDrawables.begin(), m_sortedDrawables.end(), clone.get()), m_sortedDrawables.end());
 }
 
 void Engine::addVarOrListMonitor(std::shared_ptr<Monitor> monitor, Target *target)
 {
     if (!target->isStage())
-        monitor->setSprite(dynamic_cast<Sprite *>(target));
+        monitor->setSprite(static_cast<Sprite *>(target));
 
-    monitor->setBlockSection(blockSection(monitor->opcode()));
-    auto container = blockSectionContainer(monitor->opcode());
+    IExtension *ext = blockExtension(monitor->opcode());
+    monitor->setExtension(ext);
 
-    if (container) {
-        MonitorNameFunc nameFunc = container->resolveMonitorNameFunc(monitor->opcode());
+    if (ext) {
+        MonitorNameFunc nameFunc = resolveMonitorNameFunc(ext, monitor->opcode());
 
         if (nameFunc)
             monitor->setName(nameFunc(monitor->block().get()));
 
-        MonitorChangeFunc changeFunc = container->resolveMonitorChangeFunc(monitor->opcode());
+        MonitorChangeFunc changeFunc = resolveMonitorChangeFunc(ext, monitor->opcode());
         monitor->setValueChangeFunction(changeFunc);
     }
 
-    // Auto-position the monitor
-    Rect rect = Monitor::getInitialPosition(m_monitors, monitor->width(), monitor->height());
-    monitor->setX(rect.left());
-    monitor->setY(rect.top());
-
     m_monitors.push_back(monitor);
     m_monitorAdded(monitor.get());
 
@@ -1836,12 +1973,27 @@ void Engine::updateFrameDuration()
     m_frameDuration = std::chrono::milliseconds(static_cast<long>(1000 / m_fps));
 }
 
-void Engine::addRunningScript(std::shared_ptr<VirtualMachine> vm)
+void Engine::addRunningScript(std::shared_ptr<Thread> thread)
+{
+    m_threads.push_back(thread);
+}
+
+void Engine::addBroadcastPromise(Broadcast *broadcast, Thread *sender, bool wait)
 {
-    m_threads.push_back(vm);
+    assert(broadcast);
+    assert(sender);
+
+    // Resolve broadcast promise if it's already running
+    auto it = m_broadcastSenders.find(broadcast);
+
+    if (it != m_broadcastSenders.cend() && std::find_if(m_threads.begin(), m_threads.end(), [&it](std::shared_ptr<Thread> thread) { return thread.get() == it->second; }) != m_threads.end())
+        it->second->resolvePromise();
+
+    if (wait)
+        m_broadcastSenders[broadcast] = sender;
 }
 
-std::shared_ptr<VirtualMachine> Engine::pushThread(std::shared_ptr<Block> block, Target *target)
+std::shared_ptr<Thread> Engine::pushThread(std::shared_ptr<Block> block, Target *target)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1649-L1661
     if (!block) {
@@ -1857,30 +2009,30 @@ std::shared_ptr<VirtualMachine> Engine::pushThread(std::shared_ptr<Block> block,
     }
 
     auto script = m_scripts[block];
-    std::shared_ptr<VirtualMachine> vm = script->start(target);
-    addRunningScript(vm);
-    return vm;
+    std::shared_ptr<Thread> thread = script->start(target);
+    addRunningScript(thread);
+    return thread;
 }
 
-void Engine::stopThread(VirtualMachine *thread)
+void Engine::stopThread(Thread *thread)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1667-L1672
     assert(thread);
 
-    if (!thread->atEnd())
+    if (!thread->isFinished())
         m_threadAboutToStop(thread);
 
     thread->kill();
 }
 
-std::shared_ptr<VirtualMachine> Engine::restartThread(std::shared_ptr<VirtualMachine> thread)
+std::shared_ptr<Thread> Engine::restartThread(std::shared_ptr<Thread> thread)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1681C30-L1694
-    std::shared_ptr<VirtualMachine> newThread = thread->script()->start(thread->target());
+    std::shared_ptr<Thread> newThread = thread->script()->start(thread->target());
     auto it = std::find(m_threads.begin(), m_threads.end(), thread);
 
     if (it != m_threads.end()) {
-        if (!thread->atEnd())
+        if (!thread->isFinished())
             m_threadAboutToStop(thread.get());
 
         auto i = it - m_threads.begin();
@@ -1896,36 +2048,37 @@ template<typename F>
 void Engine::allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1797-L1809
-    std::vector<Target *> *targetsPtr = &m_executableTargets;
+    std::vector<Drawable *> *drawablesPtr = &m_sortedDrawables;
 
     if (optTarget)
-        targetsPtr = new std::vector<Target *>({ optTarget });
+        drawablesPtr = new std::vector<Drawable *>({ optTarget });
+
+    const std::vector<Drawable *> &drawables = *drawablesPtr;
 
-    const std::vector<Target *> targets = *targetsPtr;
+    for (int t = drawables.size() - 1; t >= 0; t--) {
+        Drawable *drawable = drawables[t];
 
-    for (int t = targets.size() - 1; t >= 0; t--) {
-        Target *target = targets[t];
-        const auto &scripts = getHats(target, hatType);
+        if (drawable->isTarget()) {
+            Target *target = static_cast<Target *>(drawable);
+            const auto &scripts = getHats(target, hatType);
 
-        for (size_t j = 0; j < scripts.size(); j++)
-            f(scripts[j], target);
+            for (size_t j = 0; j < scripts.size(); j++)
+                f(scripts[j], target);
+        }
     }
 
     if (optTarget)
-        delete targetsPtr;
+        delete drawablesPtr;
 }
 
-std::vector<std::shared_ptr<VirtualMachine>>
-Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget)
+std::vector<std::shared_ptr<Thread>> Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1818-L1889
-    std::vector<std::shared_ptr<VirtualMachine>> newThreads;
+    std::vector<std::shared_ptr<Thread>> newThreads;
 
     allScriptsByOpcodeDo(
         hatType,
         [this, hatType, &optMatchFields, &newThreads](Script *script, Target *target) {
-            auto topBlock = script->topBlock();
-
             if (!optMatchFields.empty()) {
                 // Get the field map for this script
                 auto fieldMapIt = m_scriptHatFields.find(script);
@@ -1940,20 +2093,20 @@ Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::varia
                         assert(fieldIt != fieldMap.cend());
 
                         if (fieldIt != fieldMap.cend()) {
-                            assert(topBlock->findFieldById(fieldIt->second));
+                            assert(fieldIt->second);
 
                             if (std::holds_alternative<std::string>(fieldValue)) {
-                                if (topBlock->findFieldById(fieldIt->second)->value().toString() != std::get<std::string>(fieldValue)) {
+                                if (fieldIt->second->value().toString() != std::get<std::string>(fieldValue)) {
                                     // Field mismatch
                                     return;
                                 }
                             } else if (std::holds_alternative<const char *>(fieldValue)) {
-                                if (topBlock->findFieldById(fieldIt->second)->value().toString() != std::string(std::get<const char *>(fieldValue))) {
+                                if (fieldIt->second->value().toString() != std::string(std::get<const char *>(fieldValue))) {
                                     // Field mismatch
                                     return;
                                 }
                             } else {
-                                if (topBlock->findFieldById(fieldIt->second)->valuePtr().get() != std::get<Entity *>(fieldValue)) {
+                                if (fieldIt->second->valuePtr().get() != std::get<Entity *>(fieldValue)) {
                                     // Field mismatch
                                     return;
                                 }
@@ -1974,7 +2127,7 @@ Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::varia
             } else {
                 // Give up if any threads with the top block are running
                 for (auto thread : m_threads) {
-                    if (thread->target() == target && thread->script() == script && !thread->atEnd()) {
+                    if (thread->target() == target && thread->script() == script && !thread->isFinished()) {
                         // Some thread is already running
                         return;
                     }
@@ -1982,7 +2135,7 @@ Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::varia
             }
 
             // Start the thread with this top block
-            newThreads.push_back(pushThread(topBlock, target));
+            newThreads.push_back(pushThread(script->topBlock(), target));
         },
         optTarget);
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 218dc9ba..69d64835 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -12,14 +12,13 @@
 #include <set>
 #include <variant>
 
-#include "blocksectioncontainer.h"
-
 namespace libscratchcpp
 {
 
 class Entity;
 class IClock;
 class IAudioEngine;
+class Thread;
 
 class Engine : public IEngine
 {
@@ -34,12 +33,12 @@ class Engine : public IEngine
 
         void start() override;
         void stop() override;
-        VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *target) 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;
+        Thread *startScript(std::shared_ptr<Block> topLevelBlock, Target *target) override;
+        void broadcast(int index, Thread *sender, bool wait) override;
+        void broadcastByPtr(Broadcast *broadcast, Thread *sender, bool wait) override;
+        void startBackdropScripts(Broadcast *broadcast, Thread *sender, bool wait) override;
+        void stopScript(Thread *vm) override;
+        void stopTarget(Target *target, Thread *exceptScript) override;
         void initClone(std::shared_ptr<Sprite> clone) override;
         void deinitClone(std::shared_ptr<Sprite> clone) override;
 
@@ -54,7 +53,7 @@ class Engine : public IEngine
         void stopEventLoop() override;
 
         sigslot::signal<> &aboutToRender() override;
-        sigslot::signal<VirtualMachine *> &threadAboutToStop() override;
+        sigslot::signal<Thread *> &threadAboutToStop() override;
         sigslot::signal<> &stopped() override;
 
         bool isRunning() const override;
@@ -98,27 +97,22 @@ class Engine : public IEngine
         bool spriteFencingEnabled() const override;
         void setSpriteFencingEnabled(bool enable) override;
 
-        bool broadcastRunning(unsigned int index) override;
-        bool broadcastByPtrRunning(Broadcast *broadcast) override;
-
         void requestRedraw() override;
 
         ITimer *timer() const override;
         void setTimer(ITimer *timer);
 
-        void registerSection(std::shared_ptr<IBlockSection> section) override;
-        std::vector<std::shared_ptr<IBlockSection>> registeredSections() const;
         unsigned int functionIndex(BlockFunc f) override;
         const std::vector<BlockFunc> &blockFunctions() const override;
 
-        void addCompileFunction(IBlockSection *section, const std::string &opcode, BlockComp f) override;
-        void addHatPredicateCompileFunction(IBlockSection *section, const std::string &opcode, HatPredicateCompileFunc f) override;
-        void addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f) override;
-        void addMonitorChangeFunction(IBlockSection *section, const std::string &opcode, MonitorChangeFunc f) override;
-        void addHatBlock(IBlockSection *section, const std::string &opcode) override;
-        void addInput(IBlockSection *section, const std::string &name, int id) override;
-        void addField(IBlockSection *section, const std::string &name, int id) override;
-        void addFieldValue(IBlockSection *section, const std::string &value, int id) override;
+        void addCompileFunction(IExtension *extension, const std::string &opcode, BlockComp f) override;
+        void addHatPredicateCompileFunction(IExtension *extension, const std::string &opcode, HatPredicateCompileFunc f) override;
+        void addMonitorNameFunction(IExtension *extension, const std::string &opcode, MonitorNameFunc f) override;
+        void addMonitorChangeFunction(IExtension *extension, const std::string &opcode, MonitorChangeFunc f) override;
+        void addHatBlock(IExtension *extension, const std::string &opcode) override;
+        void addInput(IExtension *extension, const std::string &name, int id) override;
+        void addField(IExtension *extension, const std::string &name, int id) override;
+        void addFieldValue(IExtension *extension, const std::string &value, int id) override;
 
         const std::vector<std::shared_ptr<Broadcast>> &broadcasts() const override;
         void setBroadcasts(const std::vector<std::shared_ptr<Broadcast>> &broadcasts) override;
@@ -128,28 +122,31 @@ class Engine : public IEngine
 
         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;
+        void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Field *field, Broadcast *broadcast) override;
+        void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, Field *field) override;
         void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
-        void addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId) override;
+        void addKeyPressScript(std::shared_ptr<Block> hatBlock, Field *field) override;
         void addTargetClickScript(std::shared_ptr<Block> hatBlock) override;
         void addWhenGreaterThanScript(std::shared_ptr<Block> hatBlock) override;
 
         const std::vector<std::shared_ptr<Target>> &targets() const override;
         void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) override;
         Target *targetAt(int index) const override;
+        void getVisibleTargets(std::vector<Target *> &dst) const override;
         int findTarget(const std::string &targetName) const override;
 
-        void moveSpriteToFront(Sprite *sprite) override;
-        void moveSpriteToBack(Sprite *sprite) override;
-        void moveSpriteForwardLayers(Sprite *sprite, int layers) override;
-        void moveSpriteBackwardLayers(Sprite *sprite, int layers) override;
-        void moveSpriteBehindOther(Sprite *sprite, Sprite *other) override;
+        void moveDrawableToFront(Drawable *drawable) override;
+        void moveDrawableToBack(Drawable *drawable) override;
+        void moveDrawableForwardLayers(Drawable *drawable, int layers) override;
+        void moveDrawableBackwardLayers(Drawable *drawable, int layers) override;
+        void moveDrawableBehindOther(Drawable *drawable, Drawable *other) override;
 
         Stage *stage() const override;
 
         const std::vector<std::shared_ptr<Monitor>> &monitors() const override;
         void setMonitors(const std::vector<std::shared_ptr<Monitor>> &newMonitors) override;
+        Monitor *createVariableMonitor(std::shared_ptr<Variable> var, const std::string &opcode, const std::string &varFieldName, int varFieldId, BlockComp compileFunction) override;
+        Monitor *createListMonitor(std::shared_ptr<List> list, const std::string &opcode, const std::string &listFieldName, int listFieldId, BlockComp compileFunction) override;
         sigslot::signal<Monitor *> &monitorAdded() override;
         sigslot::signal<Monitor *, IMonitorHandler *> &monitorRemoved() override;
 
@@ -162,9 +159,6 @@ class Engine : public IEngine
 
         const std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> &scripts() const override;
 
-        BlockSectionContainer *blockSectionContainer(const std::string &opcode) const;
-        BlockSectionContainer *blockSectionContainer(IBlockSection *section) const;
-
         const std::string &userAgent() const override;
         void setUserAgent(const std::string &agent) override;
 
@@ -194,13 +188,24 @@ class Engine : public IEngine
             WhenGreaterThanMenu
         };
 
-        std::vector<std::shared_ptr<VirtualMachine>> stepThreads();
-        void stepThread(std::shared_ptr<VirtualMachine> thread);
+        void clearExtensionData();
+        IExtension *blockExtension(const std::string &opcode) const;
+        BlockComp resolveBlockCompileFunc(IExtension *extension, const std::string &opcode) const;
+        HatPredicateCompileFunc resolveHatPredicateCompileFunc(IExtension *extension, const std::string &opcode) const;
+        MonitorNameFunc resolveMonitorNameFunc(IExtension *extension, const std::string &opcode) const;
+        MonitorChangeFunc resolveMonitorChangeFunc(IExtension *extension, const std::string &opcode) const;
+        int resolveInput(IExtension *extension, const std::string &name) const;
+        int resolveField(IExtension *extension, const std::string &name) const;
+        int resolveFieldValue(IExtension *extension, const std::string &value) const;
+
+        void compileMonitor(std::shared_ptr<Monitor> monitor);
+
+        std::vector<std::shared_ptr<Thread>> stepThreads();
+        void stepThread(std::shared_ptr<Thread> thread);
         void eventLoop(bool untilProjectStops = false);
         void finalize();
         void deleteClones();
         void removeExecutableClones();
-        void createMissingMonitors();
         void addVarOrListMonitor(std::shared_ptr<Monitor> monitor, Target *target);
         std::shared_ptr<Block> getBlock(const std::string &id, Target *target);
         std::shared_ptr<Variable> getVariable(const std::string &id, Target *target);
@@ -208,45 +213,54 @@ class Engine : public IEngine
         std::shared_ptr<Broadcast> getBroadcast(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);
-        void addHatField(Script *script, HatField field, int fieldId);
+        void addHatField(Script *script, HatField hatField, Field *targetField);
         const std::vector<libscratchcpp::Script *> &getHats(Target *target, HatType type);
 
-        void updateSpriteLayerOrder();
+        void updateDrawableLayerOrder();
 
         void updateFrameDuration();
-        void addRunningScript(std::shared_ptr<VirtualMachine> vm);
+        void addRunningScript(std::shared_ptr<Thread> thread);
+
+        void addBroadcastPromise(Broadcast *broadcast, Thread *sender, bool wait);
 
-        std::shared_ptr<VirtualMachine> pushThread(std::shared_ptr<Block> block, Target *target);
-        void stopThread(VirtualMachine *thread);
-        std::shared_ptr<VirtualMachine> restartThread(std::shared_ptr<VirtualMachine> thread);
+        std::shared_ptr<Thread> pushThread(std::shared_ptr<Block> block, Target *target);
+        void stopThread(Thread *thread);
+        std::shared_ptr<Thread> restartThread(std::shared_ptr<Thread> thread);
 
         template<typename F>
         void allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget);
 
-        std::vector<std::shared_ptr<VirtualMachine>>
-        startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget);
+        std::vector<std::shared_ptr<Thread>> startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget);
 
         static const std::unordered_map<HatType, bool> m_hatRestartExistingThreads; // used to check whether a hat should restart existing threads
         static const std::unordered_map<HatType, bool> m_hatEdgeActivated;          // used to check whether a hat is edge-activated (runs when a predicate becomes true)
 
-        std::unordered_map<std::shared_ptr<IBlockSection>, std::unique_ptr<BlockSectionContainer>> m_sections;
         std::vector<std::shared_ptr<Target>> m_targets;
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::unordered_map<Broadcast *, std::vector<Script *>> m_broadcastMap;
+        std::unordered_map<Broadcast *, std::vector<Script *>> m_backdropBroadcastMap;
+        std::unordered_map<Broadcast *, Thread *> m_broadcastSenders; // used for resolving broadcast promises
         std::vector<std::shared_ptr<Monitor>> m_monitors;
         std::vector<std::string> m_extensions;
-        std::vector<Target *> m_executableTargets; // sorted by layer (reverse order of execution)
-        std::vector<std::shared_ptr<VirtualMachine>> m_threads;
-        std::vector<std::shared_ptr<VirtualMachine>> m_threadsToStop;
-        std::shared_ptr<VirtualMachine> m_activeThread;
+        std::vector<Drawable *> m_sortedDrawables; // sorted by layer (reverse order of execution)
+        std::vector<std::shared_ptr<Thread>> m_threads;
+        std::vector<std::shared_ptr<Thread>> m_threadsToStop;
+        std::shared_ptr<Thread> m_activeThread;
         std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> m_scripts;
         std::vector<BlockFunc> m_functions;
         std::recursive_mutex m_eventLoopMutex;
         std::string m_userAgent;
 
+        std::unordered_map<IExtension *, std::unordered_map<std::string, BlockComp>> m_compileFunctions;
+        std::unordered_map<IExtension *, std::unordered_map<std::string, HatPredicateCompileFunc>> m_hatPredicateCompileFunctions;
+        std::unordered_map<IExtension *, std::unordered_map<std::string, MonitorNameFunc>> m_monitorNameFunctions;
+        std::unordered_map<IExtension *, std::unordered_map<std::string, MonitorChangeFunc>> m_monitorChangeFunctions;
+        std::unordered_map<IExtension *, std::unordered_map<std::string, int>> m_inputs;
+        std::unordered_map<IExtension *, std::unordered_map<std::string, int>> m_fields;
+        std::unordered_map<IExtension *, std::unordered_map<std::string, int>> m_fieldValues;
+
         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;
@@ -256,7 +270,7 @@ class Engine : public IEngine
         std::unordered_map<Target *, std::vector<Script *>> m_whenTargetClickedHats;
         std::unordered_map<Target *, std::vector<Script *>> m_whenGreaterThanHats;
 
-        std::unordered_map<Script *, std::unordered_map<HatField, int>> m_scriptHatFields; // HatField, field ID from the block implementation
+        std::unordered_map<Script *, std::unordered_map<HatField, Field *>> m_scriptHatFields; // HatField, field from the block implementation
 
         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
 
@@ -277,9 +291,10 @@ class Engine : public IEngine
         bool m_spriteFencingEnabled = true;
 
         bool m_running = false;
+        bool m_frameActivity = false;
         bool m_redrawRequested = false;
         sigslot::signal<> m_aboutToRedraw;
-        sigslot::signal<VirtualMachine *> m_threadAboutToStop;
+        sigslot::signal<Thread *> m_threadAboutToStop;
         sigslot::signal<> m_stopped;
         bool m_stopEventLoop = false;
         std::mutex m_stopEventLoopMutex;
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index 2dfd39a7..3d5a3c85 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -7,6 +7,7 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/stage.h>
+#include <scratchcpp/thread.h>
 #include <iostream>
 
 #include "script_p.h"
@@ -64,7 +65,8 @@ bool Script::runHatPredicate(Target *target)
     if (!target || !impl->engine || impl->hatPredicateBytecodeVector.empty())
         return false;
 
-    auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
+    auto thread = std::make_shared<Thread>(target, impl->engine, this);
+    VirtualMachine *vm = thread->vm();
     vm->setBytecode(impl->hatPredicateBytecodeVector.data());
     vm->setConstValues(impl->constValues);
     vm->setFunctions(getFunctions());
@@ -80,15 +82,16 @@ bool Script::runHatPredicate(Target *target)
 }
 
 /*! Starts the script (creates a virtual machine). */
-std::shared_ptr<VirtualMachine> Script::start()
+std::shared_ptr<Thread> Script::start()
 {
     return start(impl->target);
 }
 
 /*! Starts the script (creates a virtual machine) as the given target (might be a clone). */
-std::shared_ptr<VirtualMachine> Script::start(Target *target)
+std::shared_ptr<Thread> Script::start(Target *target)
 {
-    auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
+    auto thread = std::make_shared<Thread>(target, impl->engine, this);
+    VirtualMachine *vm = thread->vm();
     vm->setBytecode(impl->bytecode);
     vm->setProcedures(impl->procedures);
     vm->setFunctions(getFunctions());
@@ -105,7 +108,7 @@ std::shared_ptr<VirtualMachine> Script::start(Target *target)
             std::cout << "warning: a clone tried to start a script of another target (this is a bug in libscratchcpp or in your code!)" << std::endl;
             vm->setVariables(impl->variableValues.data());
             vm->setLists(impl->lists.data());
-            return vm;
+            return thread;
         }
 
         // Use internal variables and lists from the clone
@@ -145,7 +148,7 @@ std::shared_ptr<VirtualMachine> Script::start(Target *target)
         vm->setLists(impl->lists.data());
     }
 
-    return vm;
+    return thread;
 }
 
 /*! Sets the list of procedures (custom blocks). */
diff --git a/src/engine/thread.cpp b/src/engine/thread.cpp
new file mode 100644
index 00000000..92a7fa35
--- /dev/null
+++ b/src/engine/thread.cpp
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <scratchcpp/thread.h>
+#include <scratchcpp/virtualmachine.h>
+
+#include "thread_p.h"
+
+using namespace libscratchcpp;
+
+/*! Constructs Thread. */
+Thread::Thread(Target *target, IEngine *engine, Script *script) :
+    impl(spimpl::make_unique_impl<ThreadPrivate>(target, engine, script))
+{
+    impl->vm = std::make_unique<VirtualMachine>(target, engine, script, this);
+}
+
+/*! Returns the virtual machine of this thread. */
+VirtualMachine *Thread::vm() const
+{
+    return impl->vm.get();
+}
+
+/*! Returns the Target of the script. */
+Target *Thread::target() const
+{
+    return impl->target;
+}
+
+/*! Returns the engine of the project. */
+IEngine *Thread::engine() const
+{
+    return impl->engine;
+}
+
+/*! Returns the Script. */
+Script *Thread::script() const
+{
+    return impl->script;
+}
+
+/*! Runs the script until it finishes or yields. */
+void Thread::run()
+{
+    impl->vm->run();
+}
+
+/*! Stops the script. */
+void Thread::kill()
+{
+    impl->vm->kill();
+}
+
+/*! Resets the script to run from the start. */
+void Thread::reset()
+{
+    impl->vm->reset();
+}
+
+/*! Returns true if the script is stopped or finished. */
+bool Thread::isFinished() const
+{
+    return impl->vm->atEnd();
+}
+
+/*! Pauses the script (when it's executed using run() again) until resolvePromise() is called. */
+void Thread::promise()
+{
+    impl->vm->promise();
+}
+
+/*! Resolves the promise and resumes the script. */
+void Thread::resolvePromise()
+{
+    impl->vm->resolvePromise();
+}
diff --git a/src/engine/thread_p.cpp b/src/engine/thread_p.cpp
new file mode 100644
index 00000000..c634078d
--- /dev/null
+++ b/src/engine/thread_p.cpp
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "thread_p.h"
+
+using namespace libscratchcpp;
+
+ThreadPrivate::ThreadPrivate(Target *target, IEngine *engine, Script *script) :
+    target(target),
+    engine(engine),
+    script(script)
+{
+}
diff --git a/src/engine/thread_p.h b/src/engine/thread_p.h
new file mode 100644
index 00000000..f7f9fa82
--- /dev/null
+++ b/src/engine/thread_p.h
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/virtualmachine.h>
+
+namespace libscratchcpp
+{
+
+struct ThreadPrivate
+{
+        ThreadPrivate(Target *target, IEngine *engine, Script *script);
+
+        std::unique_ptr<VirtualMachine> vm;
+        Target *target = nullptr;
+        IEngine *engine = nullptr;
+        Script *script = nullptr;
+};
+
+} // namespace libscratchcpp
diff --git a/src/engine/virtualmachine.cpp b/src/engine/virtualmachine.cpp
index 98b12248..7f66b009 100644
--- a/src/engine/virtualmachine.cpp
+++ b/src/engine/virtualmachine.cpp
@@ -10,13 +10,13 @@ using namespace vm;
 
 /*! Constructs VirtualMachine. */
 VirtualMachine::VirtualMachine() :
-    VirtualMachine(nullptr, nullptr, nullptr)
+    VirtualMachine(nullptr, nullptr, nullptr, nullptr)
 {
 }
 
 /*! \copydoc VirtualMachine() */
-VirtualMachine::VirtualMachine(Target *target, IEngine *engine, Script *script) :
-    impl(spimpl::make_unique_impl<VirtualMachinePrivate>(this, target, engine, script))
+VirtualMachine::VirtualMachine(Target *target, IEngine *engine, Script *script, Thread *thread) :
+    impl(spimpl::make_unique_impl<VirtualMachinePrivate>(this, target, engine, script, thread))
 {
 }
 
@@ -137,6 +137,12 @@ Script *VirtualMachine::script() const
     return impl->script;
 }
 
+/*! Returns the Thread this VM belongs to. */
+Thread *VirtualMachine::thread() const
+{
+    return impl->thread;
+}
+
 /*! Returns the register at the given index with the given argument (register) count. */
 const Value *VirtualMachine::getInput(unsigned int index, unsigned int argCount) const
 {
diff --git a/src/engine/virtualmachine_p.cpp b/src/engine/virtualmachine_p.cpp
index 6f2c0e4f..558d7b76 100644
--- a/src/engine/virtualmachine_p.cpp
+++ b/src/engine/virtualmachine_p.cpp
@@ -110,11 +110,12 @@ const unsigned int VirtualMachinePrivate::instruction_arg_count[] = {
     0  // OP_WARP
 };
 
-VirtualMachinePrivate::VirtualMachinePrivate(VirtualMachine *vm, Target *target, IEngine *engine, Script *script) :
+VirtualMachinePrivate::VirtualMachinePrivate(VirtualMachine *vm, Target *target, IEngine *engine, Script *script, Thread *thread) :
     vm(vm),
     target(target),
     engine(engine),
-    script(script)
+    script(script),
+    thread(thread)
 {
     regsVector.reserve(1024);
     for (int i = 0; i < 1024; i++)
@@ -460,7 +461,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     {
         const Value *v = READ_REG(0, 1);
         if (v->isNegativeInfinity())
-            REPLACE_RET_VALUE(Value(Value::SpecialValue::Infinity), 1);
+            REPLACE_RET_VALUE(Value(SpecialValue::Infinity), 1);
         else if (!v->isInfinity())
             REPLACE_RET_VALUE(std::abs(v->toDouble()), 1);
         DISPATCH();
@@ -486,7 +487,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     {
         const Value &v = *READ_REG(0, 1);
         if (v < 0)
-            REPLACE_RET_VALUE(Value(Value::SpecialValue::NaN), 1);
+            REPLACE_RET_VALUE(Value(SpecialValue::NaN), 1);
         else if (!v.isInfinity())
             REPLACE_RET_VALUE(std::sqrt(v.toDouble()), 1);
         DISPATCH();
@@ -496,7 +497,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     {
         const Value *v = READ_REG(0, 1);
         if (v->isInfinity() || v->isNegativeInfinity())
-            REPLACE_RET_VALUE(Value(Value::SpecialValue::NaN), 1);
+            REPLACE_RET_VALUE(Value(SpecialValue::NaN), 1);
         else
             REPLACE_RET_VALUE(std::sin(v->toDouble() * pi / 180), 1);
         DISPATCH();
@@ -506,7 +507,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     {
         const Value *v = READ_REG(0, 1);
         if (v->isInfinity() || v->isNegativeInfinity())
-            REPLACE_RET_VALUE(Value(Value::SpecialValue::NaN), 1);
+            REPLACE_RET_VALUE(Value(SpecialValue::NaN), 1);
         else
             REPLACE_RET_VALUE(std::cos(v->toDouble() * pi / 180), 1);
         DISPATCH();
@@ -516,7 +517,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     {
         const Value *v = READ_REG(0, 1);
         if (v->isInfinity() || v->isNegativeInfinity())
-            REPLACE_RET_VALUE(Value(Value::SpecialValue::NaN), 1);
+            REPLACE_RET_VALUE(Value(SpecialValue::NaN), 1);
         else {
             long mod;
             if (v->toLong() < 0)
@@ -524,9 +525,9 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
             else
                 mod = v->toLong() % 360;
             if (mod == 90)
-                REPLACE_RET_VALUE(Value(Value::SpecialValue::Infinity), 1);
+                REPLACE_RET_VALUE(Value(SpecialValue::Infinity), 1);
             else if (mod == 270)
-                REPLACE_RET_VALUE(Value(Value::SpecialValue::NegativeInfinity), 1);
+                REPLACE_RET_VALUE(Value(SpecialValue::NegativeInfinity), 1);
             else
                 REPLACE_RET_VALUE(std::tan(v->toDouble() * pi / 180), 1);
         }
@@ -537,7 +538,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     {
         const Value &v = *READ_REG(0, 1);
         if (v < -1 || v > 1)
-            REPLACE_RET_VALUE(Value(Value::SpecialValue::NaN), 1);
+            REPLACE_RET_VALUE(Value(SpecialValue::NaN), 1);
         else
             REPLACE_RET_VALUE(std::asin(v.toDouble()) * 180 / pi, 1);
         DISPATCH();
@@ -547,7 +548,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     {
         const Value &v = *READ_REG(0, 1);
         if (v < -1 || v > 1)
-            REPLACE_RET_VALUE(Value(Value::SpecialValue::NaN), 1);
+            REPLACE_RET_VALUE(Value(SpecialValue::NaN), 1);
         else
             REPLACE_RET_VALUE(std::acos(v.toDouble()) * 180 / pi, 1);
         DISPATCH();
@@ -609,11 +610,15 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
     DISPATCH();
 
     OP(READ_LIST) :
-        ADD_RET_VALUE(lists[*++pos]->toString());
+    {
+        std::string s;
+        lists[*++pos]->toString(s);
+        ADD_RET_VALUE(s);
+    }
     DISPATCH();
 
     OP(LIST_APPEND) :
-        lists[*++pos]->push_back(*READ_LAST_REG());
+        lists[*++pos]->append(*READ_LAST_REG());
     FREE_REGS(1);
     DISPATCH();
 
@@ -659,7 +664,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
         } else {
             const std::string &str = indexValue->toString();
             if (str == "last") {
-                list->push_back(*READ_REG(0, 2));
+                list->append(*READ_REG(0, 2));
                 index = 0;
             } else if (str == "random") {
                 size_t size = list->size();
@@ -669,7 +674,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
         }
         if ((index != 0) || list->empty()) {
             if (list->empty())
-                list->push_back(*READ_REG(0, 2));
+                list->append(*READ_REG(0, 2));
             else
                 list->insert(index - 1, *READ_REG(0, 2));
         }
@@ -696,7 +701,7 @@ unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)
                 index = 0;
         }
         if (index != 0)
-            list->operator[](index - 1) = *READ_REG(1, 2);
+            list->replace(index - 1, *READ_REG(1, 2));
         FREE_REGS(2);
         DISPATCH();
     }
diff --git a/src/engine/virtualmachine_p.h b/src/engine/virtualmachine_p.h
index 5ee86cf0..3164c730 100644
--- a/src/engine/virtualmachine_p.h
+++ b/src/engine/virtualmachine_p.h
@@ -13,13 +13,14 @@ class VirtualMachine;
 class Target;
 class IEngine;
 class Script;
+class Thread;
 class Value;
 class List;
 class IRandomGenerator;
 
 struct VirtualMachinePrivate
 {
-        VirtualMachinePrivate(VirtualMachine *vm, Target *target, IEngine *engine, Script *script);
+        VirtualMachinePrivate(VirtualMachine *vm, Target *target, IEngine *engine, Script *script, Thread *thread);
         VirtualMachinePrivate(const VirtualMachinePrivate &) = delete;
         ~VirtualMachinePrivate();
 
@@ -41,6 +42,7 @@ struct VirtualMachinePrivate
         Target *target = nullptr;
         IEngine *engine = nullptr;
         Script *script = nullptr;
+        Thread *thread = nullptr;
         unsigned int *pos = nullptr;
         unsigned int *checkpoint = nullptr;
         bool running = false;
diff --git a/src/internal/scratch3reader.cpp b/src/internal/scratch3reader.cpp
index 203cf9b6..e7e72b4a 100644
--- a/src/internal/scratch3reader.cpp
+++ b/src/internal/scratch3reader.cpp
@@ -63,7 +63,7 @@ bool Scratch3Reader::load()
                 auto list = std::make_shared<List>(it.key(), listInfo[0]);
                 auto arr = listInfo[1];
                 for (auto item : arr)
-                    list->push_back(jsonToValue(item));
+                    list->append(jsonToValue(item));
                 target->addList(list);
             }
 
@@ -408,7 +408,7 @@ bool Scratch3Reader::load()
 
                 for (auto target : m_targets) {
                     if (!target->isStage()) {
-                        Sprite *sprite = dynamic_cast<Sprite *>(target.get());
+                        Sprite *sprite = static_cast<Sprite *>(target.get());
 
                         if (sprite->name() == name) {
                             monitor->setSprite(sprite);
diff --git a/src/rect.cpp b/src/rect.cpp
index e92387e3..e2ffe180 100644
--- a/src/rect.cpp
+++ b/src/rect.cpp
@@ -78,6 +78,16 @@ double Rect::height() const
     return std::abs(impl->top - impl->bottom);
 }
 
+/*! Push out the rectangle to integer bounds. */
+void Rect::snapToInt()
+{
+    // https://github.com/scratchfoundation/scratch-render/blob/c3ede9c3d54769730c7b023021511e2aba167b1f/src/Rectangle.js#L136-L141
+    impl->left = std::floor(impl->left);
+    impl->right = std::ceil(impl->right);
+    impl->bottom = std::floor(impl->bottom);
+    impl->top = std::ceil(impl->top);
+}
+
 /*! Returns true if the rectangle intersects the given rectangle. */
 bool Rect::intersects(const Rect &rect) const
 {
diff --git a/src/scratch/CMakeLists.txt b/src/scratch/CMakeLists.txt
index d317335a..926cb2b0 100644
--- a/src/scratch/CMakeLists.txt
+++ b/src/scratch/CMakeLists.txt
@@ -1,6 +1,10 @@
 target_sources(scratchcpp
   PRIVATE
-    value.cpp
+    value_functions.cpp
+    value_functions_p.h
+    drawable.cpp
+    drawable_p.cpp
+    drawable_p.h
     target.cpp
     target_p.cpp
     target_p.h
@@ -40,6 +44,9 @@ target_sources(scratchcpp
     sprite.cpp
     sprite_p.cpp
     sprite_p.h
+    textbubble.cpp
+    textbubble_p.cpp
+    textbubble_p.h
     broadcast.cpp
     broadcast_p.cpp
     broadcast_p.h
diff --git a/src/scratch/drawable.cpp b/src/scratch/drawable.cpp
new file mode 100644
index 00000000..2b5e530d
--- /dev/null
+++ b/src/scratch/drawable.cpp
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <scratchcpp/drawable.h>
+
+#include "drawable_p.h"
+
+using namespace libscratchcpp;
+
+/*! Constructs Drawable. */
+Drawable::Drawable() :
+    impl(spimpl::make_unique_impl<DrawablePrivate>())
+{
+}
+
+/*! Returns the layer number. */
+int Drawable::layerOrder() const
+{
+    return impl->layerOrder;
+}
+
+/*! Sets the layer number. */
+void Drawable::setLayerOrder(int newLayerOrder)
+{
+    impl->layerOrder = newLayerOrder;
+}
+
+/*! Returns the engine. */
+IEngine *Drawable::engine() const
+{
+    return impl->engine;
+}
+
+/*! Sets the engine. */
+void Drawable::setEngine(IEngine *engine)
+{
+    impl->engine = engine;
+}
diff --git a/src/scratch/drawable_p.cpp b/src/scratch/drawable_p.cpp
new file mode 100644
index 00000000..227ec6b2
--- /dev/null
+++ b/src/scratch/drawable_p.cpp
@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "drawable_p.h"
+
+using namespace libscratchcpp;
diff --git a/src/scratch/drawable_p.h b/src/scratch/drawable_p.h
new file mode 100644
index 00000000..12a06331
--- /dev/null
+++ b/src/scratch/drawable_p.h
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace libscratchcpp
+{
+
+class IEngine;
+
+struct DrawablePrivate
+{
+        int layerOrder = 0;
+        IEngine *engine = nullptr;
+};
+
+} // namespace libscratchcpp
diff --git a/src/scratch/field.cpp b/src/scratch/field.cpp
index f485327b..3536d790 100644
--- a/src/scratch/field.cpp
+++ b/src/scratch/field.cpp
@@ -74,7 +74,7 @@ const std::string &Field::valueId() const
 
 /*!
  * Returns the ID that was assigned to the value.
- *  \see IBlockSection::addFieldValue()
+ *  \see IEngine::addFieldValue()
  */
 int Field::specialValueId() const
 {
@@ -83,7 +83,7 @@ int Field::specialValueId() const
 
 /*!
  * Assigns an ID to the value.
- *  \see IBlockSection::addFieldValue()
+ *  \see IEngine::addFieldValue()
  */
 void Field::setSpecialValueId(int newSpecialValueId)
 {
diff --git a/src/scratch/inputvalue.cpp b/src/scratch/inputvalue.cpp
index cb883b0d..46d4738e 100644
--- a/src/scratch/inputvalue.cpp
+++ b/src/scratch/inputvalue.cpp
@@ -13,10 +13,10 @@
 
 using namespace libscratchcpp;
 
-static const std::map<Value::Type, InputValue::Type> VALUE_TYPE_MAP = {
-    { Value::Type::Integer, InputValue::Type::Number }, { Value::Type::Double, InputValue::Type::Number },   { Value::Type::Bool, InputValue::Type::String },
-    { Value::Type::String, InputValue::Type::String },  { Value::Type::Infinity, InputValue::Type::String }, { Value::Type::NegativeInfinity, InputValue::Type::String },
-    { Value::Type::NaN, InputValue::Type::String }
+static const std::map<ValueType, InputValue::Type> VALUE_TYPE_MAP = {
+    { ValueType::Integer, InputValue::Type::Number }, { ValueType::Double, InputValue::Type::Number },   { ValueType::Bool, InputValue::Type::String },
+    { ValueType::String, InputValue::Type::String },  { ValueType::Infinity, InputValue::Type::String }, { ValueType::NegativeInfinity, InputValue::Type::String },
+    { ValueType::NaN, InputValue::Type::String }
 };
 
 /*! Constructs InputValue with the given type. */
diff --git a/src/scratch/list.cpp b/src/scratch/list.cpp
index 043077ba..668b1491 100644
--- a/src/scratch/list.cpp
+++ b/src/scratch/list.cpp
@@ -12,6 +12,14 @@ List::List(const std::string &id, const std::string &name) :
     Entity(id),
     impl(spimpl::make_unique_impl<ListPrivate>(name))
 {
+    m_dataPtr = &impl->data;
+}
+
+/*! Destroys List. */
+List::~List()
+{
+    clear();
+    reserve(m_size);
 }
 
 /*! Returns the name of the list. */
@@ -50,70 +58,14 @@ void List::setMonitor(Monitor *monitor)
     impl->monitor = monitor;
 }
 
-/*! Returns the index of the given item. */
-long List::indexOf(const Value &value) const
-{
-    auto it = std::find(begin(), end(), value);
-
-    if (it != end())
-        return it - begin();
-    else
-        return -1;
-}
-
-/*! Returns true if the list contains the given item. */
-bool List::contains(const Value &value) const
-{
-    return (indexOf(value) != -1);
-}
-
-/*! Joins the list items with spaces or without any separator if there are only digits. */
-std::string List::toString() const
-{
-    std::string ret;
-    bool digits = true;
-
-    for (const auto &item : *this) {
-        if (item.isValidNumber() && !item.toString().empty()) {
-            double doubleNum = item.toDouble();
-            long num = item.toLong();
-
-            if (doubleNum != num) {
-                digits = false;
-                break;
-            }
-
-            if (num < 0 || num >= 10) {
-                digits = false;
-                break;
-            }
-        } else {
-            digits = false;
-            break;
-        }
-    }
-
-    if (digits) {
-        for (const auto &item : *this)
-            ret.append(item.toString());
-    } else {
-        for (int i = 0; i < size(); i++) {
-            ret.append(at(i).toString());
-            if (i + 1 < size())
-                ret.push_back(' ');
-        }
-    }
-
-    return ret;
-}
-
 /*! Creates a copy of the list. */
 std::shared_ptr<List> List::clone()
 {
     auto copy = std::make_shared<List>(id(), impl->name);
+    copy->reserve(m_size);
 
-    for (const Value &item : *this)
-        copy->push_back(item);
+    for (size_t i = 0; i < m_size; i++)
+        copy->append(m_dataPtr->operator[](i));
 
     return copy;
 }
diff --git a/src/scratch/list_p.h b/src/scratch/list_p.h
index 7fed21d9..9a11a261 100644
--- a/src/scratch/list_p.h
+++ b/src/scratch/list_p.h
@@ -3,6 +3,8 @@
 #pragma once
 
 #include <string>
+#include <scratchcpp/veque.h>
+#include <scratchcpp/valuedata.h>
 
 namespace libscratchcpp
 {
@@ -17,6 +19,7 @@ struct ListPrivate
         std::string name;
         Target *target = nullptr;
         Monitor *monitor = nullptr;
+        veque::veque<ValueData> data;
 };
 
 } // namespace libscratchcpp
diff --git a/src/scratch/monitor.cpp b/src/scratch/monitor.cpp
index 47b9bd1f..10a037a0 100644
--- a/src/scratch/monitor.cpp
+++ b/src/scratch/monitor.cpp
@@ -78,24 +78,29 @@ void Monitor::setScript(std::shared_ptr<Script> script)
 }
 
 /*
- * Returns the block section of this monitor.
+ * Returns the extension this monitor belongs to.
  * \note This will return nullptr by default. Add the monitor to a project to set this property.
  */
-std::shared_ptr<IBlockSection> Monitor::blockSection() const
+IExtension *Monitor::extension() const
 {
-    return impl->blockSection;
+    return impl->extension;
 }
 
-/*! Sets the block section of this monitor. */
-void Monitor::setBlockSection(std::shared_ptr<IBlockSection> blockSection)
+/*! Sets the extension this monitor belongs to. */
+void Monitor::setExtension(IExtension *extension)
 {
-    impl->blockSection = blockSection;
+    impl->extension = extension;
 }
 
 /*! Convenience method which calls block()->target(). */
 Sprite *Monitor::sprite() const
 {
-    return dynamic_cast<Sprite *>(impl->block->target());
+    Target *target = impl->block->target();
+
+    if (target && !target->isStage())
+        return static_cast<Sprite *>(target);
+
+    return nullptr;
 }
 
 /*! Convenience method which calls block()->setTarget(). */
@@ -180,6 +185,10 @@ int Monitor::x() const
 void Monitor::setX(int x)
 {
     impl->x = x;
+    impl->needsAutoPosition = false;
+
+    if (impl->iface)
+        impl->iface->onXChanged(x);
 }
 
 /*! Returns the monitor's y-coordinate. */
@@ -192,6 +201,10 @@ int Monitor::y() const
 void Monitor::setY(int y)
 {
     impl->y = y;
+    impl->needsAutoPosition = false;
+
+    if (impl->iface)
+        impl->iface->onYChanged(y);
 }
 
 /*! Returns true if the monitor is visible. */
@@ -245,15 +258,130 @@ void Monitor::setDiscrete(bool discrete)
     impl->discrete = discrete;
 }
 
-/*! Returns the initial position of a monitor. */
-Rect Monitor::getInitialPosition(const std::vector<std::shared_ptr<Monitor>> &other, int monitorWidth, int monitorHeight)
+/*! Returns true if the monitor needs auto positioning. The renderer should call autoPosition() as soon as it knows the monitor size. */
+bool Monitor::needsAutoPosition() const
 {
-    // TODO: Implement this like Scratch has: https://github.com/scratchfoundation/scratch-gui/blob/010e27937ecff531f23bfcf3c711cd6e565cc7f9/src/reducers/monitor-layout.js#L161-L243
-    // Place the monitor randomly
+    return impl->needsAutoPosition;
+}
+
+/*!
+ * Auto-positions the monitor with the other monitors.
+ * \note Call this only when the monitor size is known.
+ */
+void Monitor::autoPosition(const std::vector<std::shared_ptr<Monitor>> &allMonitors)
+{
+    // https://github.com/scratchfoundation/scratch-gui/blob/010e27937ecff531f23bfcf3c711cd6e565cc7f9/src/reducers/monitor-layout.js#L161-L243
+    if (!impl->needsAutoPosition)
+        std::cout << "warning: auto-positioning already positioned monitor (" << impl->name << ")" << std::endl;
+
+    impl->needsAutoPosition = false;
+
+    // Try all starting positions for the new monitor to find one that doesn't intersect others
+    std::vector<int> endXs = { 0 };
+    std::vector<int> endYs = { 0 };
+    int lastX = 0;
+    int lastY = 0;
+    bool haveLastX = false;
+    bool haveLastY = false;
+
+    for (const auto monitor : allMonitors) {
+        if (monitor.get() != this) {
+            int x = monitor->x() + monitor->width();
+            x = std::ceil(x / 50.0) * 50; // Try to choose a sensible "tab width" so more monitors line up
+            endXs.push_back(x);
+            endYs.push_back(std::ceil(monitor->y() + monitor->height()));
+        }
+    }
+
+    std::sort(endXs.begin(), endXs.end());
+    std::sort(endYs.begin(), endYs.end());
+
+    // We'll use plan B if the monitor doesn't fit anywhere (too long or tall)
+    bool planB = false;
+    Rect planBRect;
+
+    for (const int x : endXs) {
+        if (haveLastX && x == lastX)
+            continue;
+
+        lastX = x;
+        haveLastX = true;
+
+        for (const int y : endYs) {
+            if (haveLastY && y == lastY)
+                continue;
+
+            lastY = y;
+            haveLastY = true;
+
+            const Rect monitorRect(x + PADDING, y + PADDING, x + PADDING + impl->width, y + PADDING + impl->height);
+
+            // Intersection testing rect that includes padding
+            const Rect rect(x, y, x + impl->width + 2 * PADDING, y + impl->height + 2 * PADDING);
+
+            bool intersected = false;
+
+            for (const auto monitor : allMonitors) {
+                if (monitor.get() != this) {
+                    const Rect currentRect(monitor->x(), monitor->y(), monitor->x() + monitor->width(), monitor->y() + monitor->height());
+
+                    if (monitorRectsIntersect(currentRect, rect)) {
+                        intersected = true;
+                        break;
+                    }
+                }
+            }
+
+            if (intersected) {
+                continue;
+            }
+
+            // If the rect overlaps the ends of the screen
+            if (rect.right() > SCREEN_WIDTH || rect.bottom() > SCREEN_HEIGHT) {
+                // If rect is not too close to completely off-screen, set it as plan B
+                if (!planB && !(rect.left() + SCREEN_EDGE_BUFFER > SCREEN_WIDTH || rect.top() + SCREEN_EDGE_BUFFER > SCREEN_HEIGHT)) {
+                    planBRect = monitorRect;
+                    planB = true;
+                }
+
+                continue;
+            }
+
+            setX(monitorRect.left());
+            setY(monitorRect.top());
+            return;
+        }
+    }
+
+    // If the monitor is too long to fit anywhere, put it in the leftmost spot available
+    // that intersects the right or bottom edge and isn't too close to the edge.
+    if (planB) {
+        setX(planBRect.left());
+        setY(planBRect.top());
+        return;
+    }
+
+    // If plan B fails and there's nowhere reasonable to put it, plan C is to place the monitor randomly
     if (!MonitorPrivate::rng)
         MonitorPrivate::rng = RandomGenerator::instance().get();
 
-    const double randX = std::ceil(MonitorPrivate::rng->randintDouble(0, SCREEN_WIDTH / 2.0));
-    const double randY = std::ceil(MonitorPrivate::rng->randintDouble(0, SCREEN_HEIGHT - SCREEN_EDGE_BUFFER));
-    return Rect(randX, randY, randX + monitorWidth, randY + monitorHeight);
+    const int randX = std::ceil(MonitorPrivate::rng->randintDouble(0, SCREEN_WIDTH / 2.0));
+    const int randY = std::ceil(MonitorPrivate::rng->randintDouble(0, SCREEN_HEIGHT - SCREEN_EDGE_BUFFER));
+    setX(randX);
+    setY(randY);
+    return;
+}
+
+bool Monitor::monitorRectsIntersect(const Rect &a, const Rect &b)
+{
+    // https://github.com/scratchfoundation/scratch-gui/blob/010e27937ecff531f23bfcf3c711cd6e565cc7f9/src/reducers/monitor-layout.js#L152-L158
+    // If one rectangle is on left side of other
+    if (a.left() >= b.right() || b.left() >= a.right())
+        return false;
+
+    // If one rectangle is above other
+    if (a.top() >= b.bottom() || b.top() >= a.bottom())
+        return false;
+
+    return true;
 }
diff --git a/src/scratch/monitor_p.h b/src/scratch/monitor_p.h
index 0e0509a2..e3e0ab64 100644
--- a/src/scratch/monitor_p.h
+++ b/src/scratch/monitor_p.h
@@ -20,7 +20,7 @@ struct MonitorPrivate
         std::string name;
         Monitor::Mode mode = Monitor::Mode::Default;
         std::shared_ptr<Script> script;
-        std::shared_ptr<IBlockSection> blockSection;
+        IExtension *extension = nullptr;
         std::shared_ptr<Block> block; // Compiler needs shared_ptr
         MonitorChangeFunc changeFunc = nullptr;
         VirtualMachine changeValueVM;
@@ -32,6 +32,7 @@ struct MonitorPrivate
         double sliderMin = 0;
         double sliderMax = 0;
         bool discrete = false;
+        bool needsAutoPosition = true;
         static IRandomGenerator *rng;
 };
 
diff --git a/src/scratch/sound.cpp b/src/scratch/sound.cpp
index e4270b72..eca5e8b9 100644
--- a/src/scratch/sound.cpp
+++ b/src/scratch/sound.cpp
@@ -11,11 +11,6 @@
 
 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),
@@ -56,13 +51,6 @@ void Sound::setVolume(double volume)
 /*! 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
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index d711ca7c..5cf80e68 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -8,6 +8,7 @@
 #include <scratchcpp/costume.h>
 #include <scratchcpp/sound.h>
 #include <scratchcpp/rect.h>
+#include <scratchcpp/textbubble.h>
 #include <cassert>
 #include <iostream>
 
@@ -20,6 +21,14 @@ Sprite::Sprite() :
     Target(),
     impl(spimpl::make_unique_impl<SpritePrivate>(this))
 {
+    bubble()->textChanged().connect([this](const std::string &text) {
+        if (impl->visible && !text.empty()) {
+            IEngine *eng = engine();
+
+            if (eng)
+                eng->requestRedraw();
+        }
+    });
 }
 
 /*! Sets the sprite interface. */
@@ -94,7 +103,7 @@ std::shared_ptr<Sprite> Sprite::clone()
             impl->iface->onCloned(clone.get());
 
         // Place the clone behind the original sprite
-        eng->moveSpriteBehindOther(clone.get(), this);
+        eng->moveDrawableBehindOther(clone.get(), this);
 
         return clone;
     }
@@ -230,7 +239,7 @@ void Sprite::startDragging()
     IEngine *eng = engine();
 
     if (eng)
-        eng->moveSpriteToFront(this);
+        eng->moveDrawableToFront(this);
 }
 
 /*! Stops dragging. */
@@ -503,6 +512,15 @@ bool Sprite::touchingColor(const Value &color) const
     return impl->iface->touchingColor(color);
 }
 
+/*! Overrides Target#touchingColor(). */
+bool Sprite::touchingColor(const Value &color, const Value &mask) const
+{
+    if (!impl->iface)
+        return false;
+
+    return impl->iface->touchingColor(color, mask);
+}
+
 /*! Overrides Target#setGraphicsEffectValue(). */
 void Sprite::setGraphicsEffectValue(IGraphicsEffect *effect, double value)
 {
@@ -535,31 +553,6 @@ void Sprite::clearGraphicsEffects()
         impl->iface->onGraphicsEffectsCleared();
 }
 
-/*! Overrides Target#setBubbleType(). */
-void Sprite::setBubbleType(BubbleType type)
-{
-    Target::setBubbleType(type);
-
-    if (impl->iface)
-        impl->iface->onBubbleTypeChanged(type);
-}
-
-/*! Overrides Target#setBubbleText(). */
-void Sprite::setBubbleText(const std::string &text)
-{
-    Target::setBubbleText(impl->visible ? text : "");
-
-    if (impl->visible && !text.empty()) {
-        IEngine *eng = engine();
-
-        if (eng)
-            eng->requestRedraw();
-    }
-
-    if (impl->iface)
-        impl->iface->onBubbleTextChanged(impl->visible ? text : "");
-}
-
 Target *Sprite::dataSource() const
 {
     return impl->cloneSprite;
diff --git a/src/scratch/stage.cpp b/src/scratch/stage.cpp
index d798451e..3a755886 100644
--- a/src/scratch/stage.cpp
+++ b/src/scratch/stage.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/stage.h>
 #include <scratchcpp/istagehandler.h>
 #include <scratchcpp/iengine.h>
+#include <scratchcpp/textbubble.h>
 #include <cassert>
 
 #include "stage_p.h"
@@ -14,6 +15,14 @@ Stage::Stage() :
     Target(),
     impl(spimpl::make_unique_impl<StagePrivate>())
 {
+    bubble()->textChanged().connect([this](const std::string &text) {
+        if (!text.empty()) {
+            IEngine *eng = engine();
+
+            if (eng)
+                eng->requestRedraw();
+        }
+    });
 }
 
 /*! Sets the stage interface. */
@@ -185,6 +194,15 @@ bool Stage::touchingColor(const Value &color) const
     return impl->iface->touchingColor(color);
 }
 
+/*! Overrides Target#touchingColor(). */
+bool Stage::touchingColor(const Value &color, const Value &mask) const
+{
+    if (!impl->iface)
+        return false;
+
+    return impl->iface->touchingColor(color, mask);
+}
+
 /*! Overrides Target#setGraphicsEffectValue(). */
 void Stage::setGraphicsEffectValue(IGraphicsEffect *effect, double value)
 {
@@ -211,31 +229,6 @@ void Stage::clearGraphicsEffects()
         impl->iface->onGraphicsEffectsCleared();
 }
 
-/*! Overrides Target#setBubbleType(). */
-void Stage::setBubbleType(BubbleType type)
-{
-    Target::setBubbleType(type);
-
-    if (impl->iface)
-        impl->iface->onBubbleTypeChanged(type);
-}
-
-/*! Overrides Target#setBubbleText(). */
-void Stage::setBubbleText(const std::string &text)
-{
-    Target::setBubbleText(text);
-
-    if (!text.empty()) {
-        IEngine *eng = engine();
-
-        if (eng)
-            eng->requestRedraw();
-    }
-
-    if (impl->iface)
-        impl->iface->onBubbleTextChanged(text);
-}
-
 bool Stage::touchingClones(const std::vector<Sprite *> &clones) const
 {
     if (!impl->iface)
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index 1e9f4b46..bb14bd97 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -7,6 +7,7 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/comment.h>
 #include <scratchcpp/iengine.h>
+#include <scratchcpp/igraphicseffect.h>
 
 #include <unordered_set>
 
@@ -16,12 +17,24 @@ using namespace libscratchcpp;
 
 static const std::unordered_set<std::string> RESERVED_NAMES = { "_mouse_", "_stage_", "_edge_", "_myself_", "_random_" };
 
+static std::unordered_map<Sound::Effect, std::pair<double, double>> SOUND_EFFECT_RANGE = {
+    { Sound::Effect::Pitch, { -360, 360 } }, // -3 to 3 octaves
+    { Sound::Effect::Pan, { -100, 100 } }    // // 100% left to 100% right
+};
+
 /*! Constructs target. */
 Target::Target() :
+    Drawable(),
     impl(spimpl::make_unique_impl<TargetPrivate>())
 {
 }
 
+/*! Returns true. */
+bool Target::isTarget() const
+{
+    return true;
+}
+
 /*! Returns the name of the target. */
 const std::string &Target::name() const
 {
@@ -267,8 +280,10 @@ void Target::setCostumeIndex(int newCostumeIndex)
         impl->costumeIndex = newCostumeIndex;
 
     if (isStage()) {
-        if (impl->engine)
-            impl->engine->requestRedraw();
+        IEngine *eng = engine();
+
+        if (eng)
+            eng->requestRedraw();
     }
 }
 
@@ -388,18 +403,6 @@ int Target::findSound(const std::string &soundName) const
         return it - impl->sounds.begin();
 }
 
-/*! Returns the layer number. */
-int Target::layerOrder() const
-{
-    return impl->layerOrder;
-}
-
-/*! Sets the layer number. */
-void Target::setLayerOrder(int newLayerOrder)
-{
-    impl->layerOrder = newLayerOrder;
-}
-
 /*! Returns the volume. */
 double Target::volume() const
 {
@@ -436,6 +439,12 @@ double Target::soundEffectValue(Sound::Effect effect) const
 /*! Sets the value of the given sound effect. */
 void Target::setSoundEffectValue(Sound::Effect effect, double value)
 {
+    auto it = SOUND_EFFECT_RANGE.find(effect);
+
+    if (it == SOUND_EFFECT_RANGE.cend())
+        return;
+
+    value = std::clamp(value, it->second.first, it->second.second);
     impl->soundEffects[effect] = value;
 
     for (auto sound : impl->sounds) {
@@ -502,9 +511,11 @@ bool Target::touchingPoint(double x, double y) const
 bool Target::touchingEdge() const
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/8dbcc1fc8f8d8c4f1e40629fe8a388149d6dfd1c/src/sprites/rendered-target.js#L772-L785
-    if (impl->engine) {
-        const double stageWidth = impl->engine->stageWidth();
-        const double stageHeight = impl->engine->stageHeight();
+    IEngine *eng = engine();
+
+    if (eng) {
+        const double stageWidth = eng->stageWidth();
+        const double stageHeight = eng->stageHeight();
         Rect bounds = boundingRect();
 
         if ((bounds.left() < -stageWidth / 2) || (bounds.right() > stageWidth / 2) || (bounds.top() > stageHeight / 2) || (bounds.bottom() < -stageHeight / 2))
@@ -520,6 +531,12 @@ bool Target::touchingColor(const Value &color) const
     return false;
 }
 
+/*! Returns true if the mask part of the Target is touching the given color (RGB triplet). */
+bool Target::touchingColor(const Value &color, const Value &mask) const
+{
+    return false;
+}
+
 /*! Returns the value of the given graphics effect. */
 double Target::graphicsEffectValue(IGraphicsEffect *effect) const
 {
@@ -534,7 +551,8 @@ double Target::graphicsEffectValue(IGraphicsEffect *effect) const
 /*! Sets the value of the given graphics effect. */
 void Target::setGraphicsEffectValue(IGraphicsEffect *effect, double value)
 {
-    impl->graphicsEffects[effect] = value;
+    assert(effect);
+    impl->graphicsEffects[effect] = effect->clamp(value);
 }
 
 /*! Sets the value of all graphics effects to 0 (clears them). */
@@ -543,45 +561,21 @@ void Target::clearGraphicsEffects()
     impl->graphicsEffects.clear();
 }
 
-/*! Returns the type of the bubble (say or think). */
-Target::BubbleType Target::bubbleType() const
-{
-    return impl->bubbleType;
-}
-
-/*! Sets the type of the bubble (say or think). */
-void Target::setBubbleType(BubbleType type)
-{
-    impl->bubbleType = type;
-}
-
-/*!
- * Returns the text of the bubble.
- * \note If the text is an empty string, the bubble is supposed to be hidden.
- */
-const std::string &Target::bubbleText() const
-{
-    return impl->bubbleText;
-}
-
-/*!
- * Sets the text of the bubble.
- * \note If the text is an empty string, the bubble is supposed to be hidden.
- */
-void Target::setBubbleText(const std::string &text)
+/*! Returns the Bubble of this Target. */
+TextBubble *Target::bubble()
 {
-    size_t limit = 330;
-    impl->bubbleText = text.substr(0, limit);
+    return &impl->bubble;
 }
 
-/*! Returns the engine. */
-IEngine *Target::engine() const
+/*! Returns the Bubble of this Target. */
+const TextBubble *Target::bubble() const
 {
-    return impl->engine;
+    return &impl->bubble;
 }
 
-/*! Sets the engine. */
+/*! Overrides Drawable#setEngine(). */
 void Target::setEngine(IEngine *engine)
 {
-    impl->engine = engine;
+    Drawable::setEngine(engine);
+    impl->bubble.setEngine(engine);
 }
diff --git a/src/scratch/target_p.h b/src/scratch/target_p.h
index 71b7c48b..eaf6206e 100644
--- a/src/scratch/target_p.h
+++ b/src/scratch/target_p.h
@@ -9,6 +9,7 @@
 #include <scratchcpp/costume.h>
 #include <scratchcpp/sound.h>
 #include <scratchcpp/target.h>
+#include <scratchcpp/textbubble.h>
 
 namespace libscratchcpp
 {
@@ -25,7 +26,6 @@ struct TargetPrivate
         TargetPrivate();
         TargetPrivate(const TargetPrivate &) = delete;
 
-        IEngine *engine = nullptr;
         std::string name;
         std::vector<std::shared_ptr<Variable>> variables;
         std::vector<std::shared_ptr<List>> lists;
@@ -34,12 +34,10 @@ struct TargetPrivate
         int costumeIndex = -1;
         std::vector<std::shared_ptr<Costume>> costumes;
         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;
+        TextBubble bubble;
 };
 
 } // namespace libscratchcpp
diff --git a/src/scratch/textbubble.cpp b/src/scratch/textbubble.cpp
new file mode 100644
index 00000000..c27aece6
--- /dev/null
+++ b/src/scratch/textbubble.cpp
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <scratchcpp/textbubble.h>
+#include <scratchcpp/value.h>
+#include <scratchcpp/iengine.h>
+
+#include "textbubble_p.h"
+
+using namespace libscratchcpp;
+
+TextBubble::TextBubble() :
+    Drawable(),
+    impl(spimpl::make_unique_impl<TextBubblePrivate>())
+{
+}
+
+/*! Returns true. */
+bool TextBubble::isTextBubble() const
+{
+    return true;
+}
+
+/*! Returns the type of the TextBubble (say or think). */
+TextBubble::Type TextBubble::type() const
+{
+    return impl->type;
+}
+
+/*! Sets the type of the TextBubble (say or think). */
+void TextBubble::setType(Type type)
+{
+    impl->type = type;
+    impl->typeChanged(type);
+}
+
+/*! Emits when the type changes. */
+sigslot::signal<TextBubble::Type> &TextBubble::typeChanged() const
+{
+    return impl->typeChanged;
+}
+
+/*!
+ * Returns the text of the TextBubble.
+ * \note If the text is an empty string, the TextBubble is supposed to be hidden.
+ */
+const std::string &TextBubble::text() const
+{
+    return impl->text;
+}
+
+/*!
+ * Sets the text of the TextBubble.
+ * \note If the text is an empty string, the TextBubble is supposed to be hidden.
+ */
+void TextBubble::setText(const std::string &text)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/7313ce5199f8a3da7850085d0f7f6a3ca2c89bf6/src/blocks/scratch3_looks.js#L251-L257
+    const Value v(text);
+    std::string converted = text;
+
+    // Non-integers should be rounded to 2 decimal places (no more, no less), unless they're small enough that rounding would display them as 0.00.
+    if (v.isValidNumber()) {
+        const double num = v.toDouble();
+
+        if (std::abs(num) >= 0.01 && (v % 1).toDouble() != 0)
+            converted = Value(std::round(num * 100) / 100).toString();
+    }
+
+    // Limit the length of the string
+    size_t limit = 330;
+    impl->text = converted.substr(0, limit);
+
+    impl->textChanged(impl->text);
+
+    if (!impl->text.empty()) {
+        IEngine *eng = engine();
+
+        if (eng)
+            eng->moveDrawableToFront(this);
+    }
+}
+
+/*! Emits when the text changes. */
+sigslot::signal<const std::string &> &TextBubble::textChanged() const
+{
+    return impl->textChanged;
+}
diff --git a/src/scratch/textbubble_p.cpp b/src/scratch/textbubble_p.cpp
new file mode 100644
index 00000000..66c6d0ba
--- /dev/null
+++ b/src/scratch/textbubble_p.cpp
@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "textbubble_p.h"
+
+using namespace libscratchcpp;
diff --git a/src/scratch/textbubble_p.h b/src/scratch/textbubble_p.h
new file mode 100644
index 00000000..118b4ebb
--- /dev/null
+++ b/src/scratch/textbubble_p.h
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/textbubble.h>
+
+namespace libscratchcpp
+{
+
+struct TextBubblePrivate
+{
+        TextBubble::Type type = TextBubble::Type::Say;
+        std::string text;
+        mutable sigslot::signal<TextBubble::Type> typeChanged;
+        mutable sigslot::signal<const std::string &> textChanged;
+};
+
+} // namespace libscratchcpp
diff --git a/src/scratch/thirdparty/fast_float/fast_float.h b/src/scratch/thirdparty/fast_float/fast_float.h
new file mode 100644
index 00000000..860001dc
--- /dev/null
+++ b/src/scratch/thirdparty/fast_float/fast_float.h
@@ -0,0 +1,3913 @@
+// fast_float by Daniel Lemire
+// fast_float by João Paulo Magalhaes
+//
+//
+// with contributions from Eugene Golushkov
+// with contributions from Maksim Kita
+// with contributions from Marcin Wojdyr
+// with contributions from Neal Richardson
+// with contributions from Tim Paine
+// with contributions from Fabio Pellacini
+// with contributions from Lénárd Szolnoki
+// with contributions from Jan Pharago
+// with contributions from Maya Warrier
+// with contributions from Taha Khokhar
+//
+//
+// Licensed under the Apache License, Version 2.0, or the
+// MIT License or the Boost License. This file may not be copied,
+// modified, or distributed except according to those terms.
+//
+// MIT License Notice
+//
+//    MIT License
+//    
+//    Copyright (c) 2021 The fast_float authors
+//    
+//    Permission is hereby granted, free of charge, to any
+//    person obtaining a copy of this software and associated
+//    documentation files (the "Software"), to deal in the
+//    Software without restriction, including without
+//    limitation the rights to use, copy, modify, merge,
+//    publish, distribute, sublicense, and/or sell copies of
+//    the Software, and to permit persons to whom the Software
+//    is furnished to do so, subject to the following
+//    conditions:
+//    
+//    The above copyright notice and this permission notice
+//    shall be included in all copies or substantial portions
+//    of the Software.
+//    
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+//    ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+//    TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+//    SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+//    IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+//    DEALINGS IN THE SOFTWARE.
+//
+// Apache License (Version 2.0) Notice
+//
+//    Copyright 2021 The fast_float authors
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//    
+//    http://www.apache.org/licenses/LICENSE-2.0
+//    
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//
+// BOOST License Notice
+//
+//    Boost Software License - Version 1.0 - August 17th, 2003
+//    
+//    Permission is hereby granted, free of charge, to any person or organization
+//    obtaining a copy of the software and accompanying documentation covered by
+//    this license (the "Software") to use, reproduce, display, distribute,
+//    execute, and transmit the Software, and to prepare derivative works of the
+//    Software, and to permit third-parties to whom the Software is furnished to
+//    do so, all subject to the following:
+//    
+//    The copyright notices in the Software and this entire statement, including
+//    the above license grant, this restriction and the following disclaimer,
+//    must be included in all copies of the Software, in whole or in part, and
+//    all derivative works of the Software, unless such copies or derivative
+//    works are solely in the form of machine-executable object code generated by
+//    a source language processor.
+//    
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//    FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+//    SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+//    FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+//    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+//    DEALINGS IN THE SOFTWARE.
+//
+
+#ifndef FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+#define FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+
+#ifdef __has_include
+#if __has_include(<version>)
+#include <version>
+#endif
+#endif
+
+// Testing for https://wg21.link/N3652, adopted in C++14
+#if __cpp_constexpr >= 201304
+#define FASTFLOAT_CONSTEXPR14 constexpr
+#else
+#define FASTFLOAT_CONSTEXPR14
+#endif
+
+#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+#define FASTFLOAT_HAS_BIT_CAST 1
+#else
+#define FASTFLOAT_HAS_BIT_CAST 0
+#endif
+
+#if defined(__cpp_lib_is_constant_evaluated) &&                                \
+    __cpp_lib_is_constant_evaluated >= 201811L
+#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 1
+#else
+#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 0
+#endif
+
+// Testing for relevant C++20 constexpr library features
+#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED && FASTFLOAT_HAS_BIT_CAST &&           \
+    __cpp_lib_constexpr_algorithms >= 201806L /*For std::copy and std::fill*/
+#define FASTFLOAT_CONSTEXPR20 constexpr
+#define FASTFLOAT_IS_CONSTEXPR 1
+#else
+#define FASTFLOAT_CONSTEXPR20
+#define FASTFLOAT_IS_CONSTEXPR 0
+#endif
+
+#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#define FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE 0
+#else
+#define FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE 1
+#endif
+
+#endif // FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+
+#ifndef FASTFLOAT_FLOAT_COMMON_H
+#define FASTFLOAT_FLOAT_COMMON_H
+
+#include <cfloat>
+#include <cstdint>
+#include <cassert>
+#include <cstring>
+#include <type_traits>
+#include <system_error>
+#ifdef __has_include
+#if __has_include(<stdfloat>) && (__cplusplus > 202002L || _MSVC_LANG > 202002L)
+#include <stdfloat>
+#endif
+#endif
+
+namespace fast_float {
+
+#define FASTFLOAT_JSONFMT (1 << 5)
+#define FASTFLOAT_FORTRANFMT (1 << 6)
+
+enum chars_format {
+  scientific = 1 << 0,
+  fixed = 1 << 2,
+  hex = 1 << 3,
+  no_infnan = 1 << 4,
+  // RFC 8259: https://datatracker.ietf.org/doc/html/rfc8259#section-6
+  json = FASTFLOAT_JSONFMT | fixed | scientific | no_infnan,
+  // Extension of RFC 8259 where, e.g., "inf" and "nan" are allowed.
+  json_or_infnan = FASTFLOAT_JSONFMT | fixed | scientific,
+  fortran = FASTFLOAT_FORTRANFMT | fixed | scientific,
+  general = fixed | scientific
+};
+
+template <typename UC> struct from_chars_result_t {
+  UC const *ptr;
+  std::errc ec;
+};
+using from_chars_result = from_chars_result_t<char>;
+
+template <typename UC> struct parse_options_t {
+  constexpr explicit parse_options_t(chars_format fmt = chars_format::general,
+                                     UC dot = UC('.'))
+      : format(fmt), decimal_point(dot) {}
+
+  /** Which number formats are accepted */
+  chars_format format;
+  /** The character used as decimal point */
+  UC decimal_point;
+};
+using parse_options = parse_options_t<char>;
+
+} // namespace fast_float
+
+#if FASTFLOAT_HAS_BIT_CAST
+#include <bit>
+#endif
+
+#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) ||            \
+     defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) ||          \
+     defined(__MINGW64__) || defined(__s390x__) ||                             \
+     (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) ||      \
+      defined(__PPC64LE__)) ||                                                 \
+     defined(__loongarch64))
+#define FASTFLOAT_64BIT 1
+#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86) ||             \
+       defined(__arm__) || defined(_M_ARM) || defined(__ppc__) ||              \
+       defined(__MINGW32__) || defined(__EMSCRIPTEN__))
+#define FASTFLOAT_32BIT 1
+#else
+  // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow.
+// We can never tell the register width, but the SIZE_MAX is a good
+// approximation. UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max
+// portability.
+#if SIZE_MAX == 0xffff
+#error Unknown platform (16-bit, unsupported)
+#elif SIZE_MAX == 0xffffffff
+#define FASTFLOAT_32BIT 1
+#elif SIZE_MAX == 0xffffffffffffffff
+#define FASTFLOAT_64BIT 1
+#else
+#error Unknown platform (not 32-bit, not 64-bit?)
+#endif
+#endif
+
+#if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__)) ||           \
+    (defined(_M_ARM64) && !defined(__MINGW32__))
+#include <intrin.h>
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define FASTFLOAT_VISUAL_STUDIO 1
+#endif
+
+#if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__
+#define FASTFLOAT_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#elif defined _WIN32
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <machine/endian.h>
+#elif defined(sun) || defined(__sun)
+#include <sys/byteorder.h>
+#elif defined(__MVS__)
+#include <sys/endian.h>
+#else
+#ifdef __has_include
+#if __has_include(<endian.h>)
+#include <endian.h>
+#endif //__has_include(<endian.h>)
+#endif //__has_include
+#endif
+#
+#ifndef __BYTE_ORDER__
+// safe choice
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#ifndef __ORDER_LITTLE_ENDIAN__
+// safe choice
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#define FASTFLOAT_IS_BIG_ENDIAN 1
+#endif
+#endif
+
+#if defined(__SSE2__) || (defined(FASTFLOAT_VISUAL_STUDIO) &&                  \
+                          (defined(_M_AMD64) || defined(_M_X64) ||             \
+                           (defined(_M_IX86_FP) && _M_IX86_FP == 2)))
+#define FASTFLOAT_SSE2 1
+#endif
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+#define FASTFLOAT_NEON 1
+#endif
+
+#if defined(FASTFLOAT_SSE2) || defined(FASTFLOAT_NEON)
+#define FASTFLOAT_HAS_SIMD 1
+#endif
+
+#if defined(__GNUC__)
+// disable -Wcast-align=strict (GCC only)
+#define FASTFLOAT_SIMD_DISABLE_WARNINGS                                        \
+  _Pragma("GCC diagnostic push")                                               \
+      _Pragma("GCC diagnostic ignored \"-Wcast-align\"")
+#else
+#define FASTFLOAT_SIMD_DISABLE_WARNINGS
+#endif
+
+#if defined(__GNUC__)
+#define FASTFLOAT_SIMD_RESTORE_WARNINGS _Pragma("GCC diagnostic pop")
+#else
+#define FASTFLOAT_SIMD_RESTORE_WARNINGS
+#endif
+
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#define fastfloat_really_inline __forceinline
+#else
+#define fastfloat_really_inline inline __attribute__((always_inline))
+#endif
+
+#ifndef FASTFLOAT_ASSERT
+#define FASTFLOAT_ASSERT(x)                                                    \
+  { ((void)(x)); }
+#endif
+
+#ifndef FASTFLOAT_DEBUG_ASSERT
+#define FASTFLOAT_DEBUG_ASSERT(x)                                              \
+  { ((void)(x)); }
+#endif
+
+// rust style `try!()` macro, or `?` operator
+#define FASTFLOAT_TRY(x)                                                       \
+  {                                                                            \
+    if (!(x))                                                                  \
+      return false;                                                            \
+  }
+
+#define FASTFLOAT_ENABLE_IF(...)                                               \
+  typename std::enable_if<(__VA_ARGS__), int>::type
+
+namespace fast_float {
+
+fastfloat_really_inline constexpr bool cpp20_and_in_constexpr() {
+#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED
+  return std::is_constant_evaluated();
+#else
+  return false;
+#endif
+}
+
+template <typename T>
+fastfloat_really_inline constexpr bool is_supported_float_type() {
+  return std::is_same<T, float>::value || std::is_same<T, double>::value
+#if __STDCPP_FLOAT32_T__
+         || std::is_same<T, std::float32_t>::value
+#endif
+#if __STDCPP_FLOAT64_T__
+         || std::is_same<T, std::float64_t>::value
+#endif
+      ;
+}
+
+template <typename UC>
+fastfloat_really_inline constexpr bool is_supported_char_type() {
+  return std::is_same<UC, char>::value || std::is_same<UC, wchar_t>::value ||
+         std::is_same<UC, char16_t>::value || std::is_same<UC, char32_t>::value;
+}
+
+// Compares two ASCII strings in a case insensitive manner.
+template <typename UC>
+inline FASTFLOAT_CONSTEXPR14 bool
+fastfloat_strncasecmp(UC const *input1, UC const *input2, size_t length) {
+  char running_diff{0};
+  for (size_t i = 0; i < length; ++i) {
+    running_diff |= (char(input1[i]) ^ char(input2[i]));
+  }
+  return (running_diff == 0) || (running_diff == 32);
+}
+
+#ifndef FLT_EVAL_METHOD
+#error "FLT_EVAL_METHOD should be defined, please include cfloat."
+#endif
+
+// a pointer and a length to a contiguous block of memory
+template <typename T> struct span {
+  const T *ptr;
+  size_t length;
+  constexpr span(const T *_ptr, size_t _length) : ptr(_ptr), length(_length) {}
+  constexpr span() : ptr(nullptr), length(0) {}
+
+  constexpr size_t len() const noexcept { return length; }
+
+  FASTFLOAT_CONSTEXPR14 const T &operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return ptr[index];
+  }
+};
+
+struct value128 {
+  uint64_t low;
+  uint64_t high;
+  constexpr value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
+  constexpr value128() : low(0), high(0) {}
+};
+
+/* Helper C++14 constexpr generic implementation of leading_zeroes */
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 int
+leading_zeroes_generic(uint64_t input_num, int last_bit = 0) {
+  if (input_num & uint64_t(0xffffffff00000000)) {
+    input_num >>= 32;
+    last_bit |= 32;
+  }
+  if (input_num & uint64_t(0xffff0000)) {
+    input_num >>= 16;
+    last_bit |= 16;
+  }
+  if (input_num & uint64_t(0xff00)) {
+    input_num >>= 8;
+    last_bit |= 8;
+  }
+  if (input_num & uint64_t(0xf0)) {
+    input_num >>= 4;
+    last_bit |= 4;
+  }
+  if (input_num & uint64_t(0xc)) {
+    input_num >>= 2;
+    last_bit |= 2;
+  }
+  if (input_num & uint64_t(0x2)) { /* input_num >>=  1; */
+    last_bit |= 1;
+  }
+  return 63 - last_bit;
+}
+
+/* result might be undefined when input_num is zero */
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 int
+leading_zeroes(uint64_t input_num) {
+  assert(input_num > 0);
+  if (cpp20_and_in_constexpr()) {
+    return leading_zeroes_generic(input_num);
+  }
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#if defined(_M_X64) || defined(_M_ARM64)
+  unsigned long leading_zero = 0;
+  // Search the mask data from most significant bit (MSB)
+  // to least significant bit (LSB) for a set bit (1).
+  _BitScanReverse64(&leading_zero, input_num);
+  return (int)(63 - leading_zero);
+#else
+  return leading_zeroes_generic(input_num);
+#endif
+#else
+  return __builtin_clzll(input_num);
+#endif
+}
+
+// slow emulation routine for 32-bit
+fastfloat_really_inline constexpr uint64_t emulu(uint32_t x, uint32_t y) {
+  return x * (uint64_t)y;
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 uint64_t
+umul128_generic(uint64_t ab, uint64_t cd, uint64_t *hi) {
+  uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
+  uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
+  uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
+  uint64_t adbc_carry = (uint64_t)(adbc < ad);
+  uint64_t lo = bd + (adbc << 32);
+  *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
+        (adbc_carry << 32) + (uint64_t)(lo < bd);
+  return lo;
+}
+
+#ifdef FASTFLOAT_32BIT
+
+// slow emulation routine for 32-bit
+#if !defined(__MINGW64__)
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 uint64_t _umul128(uint64_t ab,
+                                                                uint64_t cd,
+                                                                uint64_t *hi) {
+  return umul128_generic(ab, cd, hi);
+}
+#endif // !__MINGW64__
+
+#endif // FASTFLOAT_32BIT
+
+// compute 64-bit a*b
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 value128
+full_multiplication(uint64_t a, uint64_t b) {
+  if (cpp20_and_in_constexpr()) {
+    value128 answer;
+    answer.low = umul128_generic(a, b, &answer.high);
+    return answer;
+  }
+  value128 answer;
+#if defined(_M_ARM64) && !defined(__MINGW32__)
+  // ARM64 has native support for 64-bit multiplications, no need to emulate
+  // But MinGW on ARM64 doesn't have native support for 64-bit multiplications
+  answer.high = __umulh(a, b);
+  answer.low = a * b;
+#elif defined(FASTFLOAT_32BIT) ||                                              \
+    (defined(_WIN64) && !defined(__clang__) && !defined(_M_ARM64))
+  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
+#elif defined(FASTFLOAT_64BIT) && defined(__SIZEOF_INT128__)
+  __uint128_t r = ((__uint128_t)a) * b;
+  answer.low = uint64_t(r);
+  answer.high = uint64_t(r >> 64);
+#else
+  answer.low = umul128_generic(a, b, &answer.high);
+#endif
+  return answer;
+}
+
+struct adjusted_mantissa {
+  uint64_t mantissa{0};
+  int32_t power2{0}; // a negative value indicates an invalid result
+  adjusted_mantissa() = default;
+  constexpr bool operator==(const adjusted_mantissa &o) const {
+    return mantissa == o.mantissa && power2 == o.power2;
+  }
+  constexpr bool operator!=(const adjusted_mantissa &o) const {
+    return mantissa != o.mantissa || power2 != o.power2;
+  }
+};
+
+// Bias so we can get the real exponent with an invalid adjusted_mantissa.
+constexpr static int32_t invalid_am_bias = -0x8000;
+
+// used for binary_format_lookup_tables<T>::max_mantissa
+constexpr uint64_t constant_55555 = 5 * 5 * 5 * 5 * 5;
+
+template <typename T, typename U = void> struct binary_format_lookup_tables;
+
+template <typename T> struct binary_format : binary_format_lookup_tables<T> {
+  using equiv_uint =
+      typename std::conditional<sizeof(T) == 4, uint32_t, uint64_t>::type;
+
+  static inline constexpr int mantissa_explicit_bits();
+  static inline constexpr int minimum_exponent();
+  static inline constexpr int infinite_power();
+  static inline constexpr int sign_index();
+  static inline constexpr int
+  min_exponent_fast_path(); // used when fegetround() == FE_TONEAREST
+  static inline constexpr int max_exponent_fast_path();
+  static inline constexpr int max_exponent_round_to_even();
+  static inline constexpr int min_exponent_round_to_even();
+  static inline constexpr uint64_t max_mantissa_fast_path(int64_t power);
+  static inline constexpr uint64_t
+  max_mantissa_fast_path(); // used when fegetround() == FE_TONEAREST
+  static inline constexpr int largest_power_of_ten();
+  static inline constexpr int smallest_power_of_ten();
+  static inline constexpr T exact_power_of_ten(int64_t power);
+  static inline constexpr size_t max_digits();
+  static inline constexpr equiv_uint exponent_mask();
+  static inline constexpr equiv_uint mantissa_mask();
+  static inline constexpr equiv_uint hidden_bit_mask();
+};
+
+template <typename U> struct binary_format_lookup_tables<double, U> {
+  static constexpr double powers_of_ten[] = {
+      1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
+      1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+
+  // Largest integer value v so that (5**index * v) <= 1<<53.
+  // 0x20000000000000 == 1 << 53
+  static constexpr uint64_t max_mantissa[] = {
+      0x20000000000000,
+      0x20000000000000 / 5,
+      0x20000000000000 / (5 * 5),
+      0x20000000000000 / (5 * 5 * 5),
+      0x20000000000000 / (5 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555),
+      0x20000000000000 / (constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5 * 5 * 5)};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr double binary_format_lookup_tables<double, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t binary_format_lookup_tables<double, U>::max_mantissa[];
+
+#endif
+
+template <typename U> struct binary_format_lookup_tables<float, U> {
+  static constexpr float powers_of_ten[] = {1e0f, 1e1f, 1e2f, 1e3f, 1e4f, 1e5f,
+                                            1e6f, 1e7f, 1e8f, 1e9f, 1e10f};
+
+  // Largest integer value v so that (5**index * v) <= 1<<24.
+  // 0x1000000 == 1<<24
+  static constexpr uint64_t max_mantissa[] = {
+      0x1000000,
+      0x1000000 / 5,
+      0x1000000 / (5 * 5),
+      0x1000000 / (5 * 5 * 5),
+      0x1000000 / (5 * 5 * 5 * 5),
+      0x1000000 / (constant_55555),
+      0x1000000 / (constant_55555 * 5),
+      0x1000000 / (constant_55555 * 5 * 5),
+      0x1000000 / (constant_55555 * 5 * 5 * 5),
+      0x1000000 / (constant_55555 * 5 * 5 * 5 * 5),
+      0x1000000 / (constant_55555 * constant_55555),
+      0x1000000 / (constant_55555 * constant_55555 * 5)};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr float binary_format_lookup_tables<float, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t binary_format_lookup_tables<float, U>::max_mantissa[];
+
+#endif
+
+template <>
+inline constexpr int binary_format<double>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return 0;
+#else
+  return -22;
+#endif
+}
+
+template <>
+inline constexpr int binary_format<float>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return 0;
+#else
+  return -10;
+#endif
+}
+
+template <>
+inline constexpr int binary_format<double>::mantissa_explicit_bits() {
+  return 52;
+}
+template <>
+inline constexpr int binary_format<float>::mantissa_explicit_bits() {
+  return 23;
+}
+
+template <>
+inline constexpr int binary_format<double>::max_exponent_round_to_even() {
+  return 23;
+}
+
+template <>
+inline constexpr int binary_format<float>::max_exponent_round_to_even() {
+  return 10;
+}
+
+template <>
+inline constexpr int binary_format<double>::min_exponent_round_to_even() {
+  return -4;
+}
+
+template <>
+inline constexpr int binary_format<float>::min_exponent_round_to_even() {
+  return -17;
+}
+
+template <> inline constexpr int binary_format<double>::minimum_exponent() {
+  return -1023;
+}
+template <> inline constexpr int binary_format<float>::minimum_exponent() {
+  return -127;
+}
+
+template <> inline constexpr int binary_format<double>::infinite_power() {
+  return 0x7FF;
+}
+template <> inline constexpr int binary_format<float>::infinite_power() {
+  return 0xFF;
+}
+
+template <> inline constexpr int binary_format<double>::sign_index() {
+  return 63;
+}
+template <> inline constexpr int binary_format<float>::sign_index() {
+  return 31;
+}
+
+template <>
+inline constexpr int binary_format<double>::max_exponent_fast_path() {
+  return 22;
+}
+template <>
+inline constexpr int binary_format<float>::max_exponent_fast_path() {
+  return 10;
+}
+
+template <>
+inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+template <>
+inline constexpr uint64_t
+binary_format<double>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 22
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+template <>
+inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+template <>
+inline constexpr uint64_t
+binary_format<float>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 10
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr double
+binary_format<double>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+template <>
+inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+
+template <> inline constexpr int binary_format<double>::largest_power_of_ten() {
+  return 308;
+}
+template <> inline constexpr int binary_format<float>::largest_power_of_ten() {
+  return 38;
+}
+
+template <>
+inline constexpr int binary_format<double>::smallest_power_of_ten() {
+  return -342;
+}
+template <> inline constexpr int binary_format<float>::smallest_power_of_ten() {
+  return -64;
+}
+
+template <> inline constexpr size_t binary_format<double>::max_digits() {
+  return 769;
+}
+template <> inline constexpr size_t binary_format<float>::max_digits() {
+  return 114;
+}
+
+template <>
+inline constexpr binary_format<float>::equiv_uint
+binary_format<float>::exponent_mask() {
+  return 0x7F800000;
+}
+template <>
+inline constexpr binary_format<double>::equiv_uint
+binary_format<double>::exponent_mask() {
+  return 0x7FF0000000000000;
+}
+
+template <>
+inline constexpr binary_format<float>::equiv_uint
+binary_format<float>::mantissa_mask() {
+  return 0x007FFFFF;
+}
+template <>
+inline constexpr binary_format<double>::equiv_uint
+binary_format<double>::mantissa_mask() {
+  return 0x000FFFFFFFFFFFFF;
+}
+
+template <>
+inline constexpr binary_format<float>::equiv_uint
+binary_format<float>::hidden_bit_mask() {
+  return 0x00800000;
+}
+template <>
+inline constexpr binary_format<double>::equiv_uint
+binary_format<double>::hidden_bit_mask() {
+  return 0x0010000000000000;
+}
+
+template <typename T>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+to_float(bool negative, adjusted_mantissa am, T &value) {
+  using fastfloat_uint = typename binary_format<T>::equiv_uint;
+  fastfloat_uint word = (fastfloat_uint)am.mantissa;
+  word |= fastfloat_uint(am.power2)
+          << binary_format<T>::mantissa_explicit_bits();
+  word |= fastfloat_uint(negative) << binary_format<T>::sign_index();
+#if FASTFLOAT_HAS_BIT_CAST
+  value = std::bit_cast<T>(word);
+#else
+  ::memcpy(&value, &word, sizeof(T));
+#endif
+}
+
+#ifdef FASTFLOAT_SKIP_WHITE_SPACE // disabled by default
+template <typename = void> struct space_lut {
+  static constexpr bool value[] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr bool space_lut<T>::value[];
+
+#endif
+
+inline constexpr bool is_space(uint8_t c) { return space_lut<>::value[c]; }
+#endif
+
+template <typename UC> static constexpr uint64_t int_cmp_zeros() {
+  static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4),
+                "Unsupported character size");
+  return (sizeof(UC) == 1) ? 0x3030303030303030
+         : (sizeof(UC) == 2)
+             ? (uint64_t(UC('0')) << 48 | uint64_t(UC('0')) << 32 |
+                uint64_t(UC('0')) << 16 | UC('0'))
+             : (uint64_t(UC('0')) << 32 | UC('0'));
+}
+template <typename UC> static constexpr int int_cmp_len() {
+  return sizeof(uint64_t) / sizeof(UC);
+}
+template <typename UC> static constexpr UC const *str_const_nan() {
+  return nullptr;
+}
+template <> constexpr char const *str_const_nan<char>() { return "nan"; }
+template <> constexpr wchar_t const *str_const_nan<wchar_t>() { return L"nan"; }
+template <> constexpr char16_t const *str_const_nan<char16_t>() {
+  return u"nan";
+}
+template <> constexpr char32_t const *str_const_nan<char32_t>() {
+  return U"nan";
+}
+template <typename UC> static constexpr UC const *str_const_inf() {
+  return nullptr;
+}
+template <> constexpr char const *str_const_inf<char>() { return "infinity"; }
+template <> constexpr wchar_t const *str_const_inf<wchar_t>() {
+  return L"infinity";
+}
+template <> constexpr char16_t const *str_const_inf<char16_t>() {
+  return u"infinity";
+}
+template <> constexpr char32_t const *str_const_inf<char32_t>() {
+  return U"infinity";
+}
+
+template <typename = void> struct int_luts {
+  static constexpr uint8_t chdigit[] = {
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   255, 255,
+      255, 255, 255, 255, 255, 10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+      20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,
+      35,  255, 255, 255, 255, 255, 255, 10,  11,  12,  13,  14,  15,  16,  17,
+      18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,
+      33,  34,  35,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255};
+
+  static constexpr size_t maxdigits_u64[] = {
+      64, 41, 32, 28, 25, 23, 22, 21, 20, 19, 18, 18, 17, 17, 16, 16, 16, 16,
+      15, 15, 15, 15, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13};
+
+  static constexpr uint64_t min_safe_u64[] = {
+      9223372036854775808ull,  12157665459056928801ull, 4611686018427387904,
+      7450580596923828125,     4738381338321616896,     3909821048582988049,
+      9223372036854775808ull,  12157665459056928801ull, 10000000000000000000ull,
+      5559917313492231481,     2218611106740436992,     8650415919381337933,
+      2177953337809371136,     6568408355712890625,     1152921504606846976,
+      2862423051509815793,     6746640616477458432,     15181127029874798299ull,
+      1638400000000000000,     3243919932521508681,     6221821273427820544,
+      11592836324538749809ull, 876488338465357824,      1490116119384765625,
+      2481152873203736576,     4052555153018976267,     6502111422497947648,
+      10260628712958602189ull, 15943230000000000000ull, 787662783788549761,
+      1152921504606846976,     1667889514952984961,     2386420683693101056,
+      3379220508056640625,     4738381338321616896};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr uint8_t int_luts<T>::chdigit[];
+
+template <typename T> constexpr size_t int_luts<T>::maxdigits_u64[];
+
+template <typename T> constexpr uint64_t int_luts<T>::min_safe_u64[];
+
+#endif
+
+template <typename UC>
+fastfloat_really_inline constexpr uint8_t ch_to_digit(UC c) {
+  return int_luts<>::chdigit[static_cast<unsigned char>(c)];
+}
+
+fastfloat_really_inline constexpr size_t max_digits_u64(int base) {
+  return int_luts<>::maxdigits_u64[base - 2];
+}
+
+// If a u64 is exactly max_digits_u64() in length, this is
+// the value below which it has definitely overflowed.
+fastfloat_really_inline constexpr uint64_t min_safe_u64(int base) {
+  return int_luts<>::min_safe_u64[base - 2];
+}
+
+} // namespace fast_float
+
+#endif
+
+
+#ifndef FASTFLOAT_FAST_FLOAT_H
+#define FASTFLOAT_FAST_FLOAT_H
+
+
+namespace fast_float {
+/**
+ * This function parses the character sequence [first,last) for a number. It
+ * parses floating-point numbers expecting a locale-indepent format equivalent
+ * to what is used by std::strtod in the default ("C") locale. The resulting
+ * floating-point value is the closest floating-point values (using either float
+ * or double), using the "round to even" convention for values that would
+ * otherwise fall right in-between two values. That is, we provide exact parsing
+ * according to the IEEE standard.
+ *
+ * Given a successful parse, the pointer (`ptr`) in the returned value is set to
+ * point right after the parsed number, and the `value` referenced is set to the
+ * parsed value. In case of error, the returned `ec` contains a representative
+ * error, otherwise the default (`std::errc()`) value is stored.
+ *
+ * The implementation does not throw and does not allocate memory (e.g., with
+ * `new` or `malloc`).
+ *
+ * Like the C++17 standard, the `fast_float::from_chars` functions take an
+ * optional last argument of the type `fast_float::chars_format`. It is a bitset
+ * value: we check whether `fmt & fast_float::chars_format::fixed` and `fmt &
+ * fast_float::chars_format::scientific` are set to determine whether we allow
+ * the fixed point and scientific notation respectively. The default is
+ * `fast_float::chars_format::general` which allows both `fixed` and
+ * `scientific`.
+ */
+template <typename T, typename UC = char,
+          typename = FASTFLOAT_ENABLE_IF(is_supported_float_type<T>())>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value,
+           chars_format fmt = chars_format::general) noexcept;
+
+/**
+ * Like from_chars, but accepts an `options` argument to govern number parsing.
+ */
+template <typename T, typename UC = char>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(UC const *first, UC const *last, T &value,
+                    parse_options_t<UC> options) noexcept;
+/**
+ * from_chars for integer types.
+ */
+template <typename T, typename UC = char,
+          typename = FASTFLOAT_ENABLE_IF(!is_supported_float_type<T>())>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value, int base = 10) noexcept;
+
+} // namespace fast_float
+#endif // FASTFLOAT_FAST_FLOAT_H
+
+#ifndef FASTFLOAT_ASCII_NUMBER_H
+#define FASTFLOAT_ASCII_NUMBER_H
+
+#include <cctype>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <type_traits>
+
+
+#ifdef FASTFLOAT_SSE2
+#include <emmintrin.h>
+#endif
+
+#ifdef FASTFLOAT_NEON
+#include <arm_neon.h>
+#endif
+
+namespace fast_float {
+
+template <typename UC> fastfloat_really_inline constexpr bool has_simd_opt() {
+#ifdef FASTFLOAT_HAS_SIMD
+  return std::is_same<UC, char16_t>::value;
+#else
+  return false;
+#endif
+}
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+template <typename UC>
+fastfloat_really_inline constexpr bool is_integer(UC c) noexcept {
+  return !(c > UC('9') || c < UC('0'));
+}
+
+fastfloat_really_inline constexpr uint64_t byteswap(uint64_t val) {
+  return (val & 0xFF00000000000000) >> 56 | (val & 0x00FF000000000000) >> 40 |
+         (val & 0x0000FF0000000000) >> 24 | (val & 0x000000FF00000000) >> 8 |
+         (val & 0x00000000FF000000) << 8 | (val & 0x0000000000FF0000) << 24 |
+         (val & 0x000000000000FF00) << 40 | (val & 0x00000000000000FF) << 56;
+}
+
+// Read 8 UC into a u64. Truncates UC if not char.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint64_t
+read8_to_u64(const UC *chars) {
+  if (cpp20_and_in_constexpr() || !std::is_same<UC, char>::value) {
+    uint64_t val = 0;
+    for (int i = 0; i < 8; ++i) {
+      val |= uint64_t(uint8_t(*chars)) << (i * 8);
+      ++chars;
+    }
+    return val;
+  }
+  uint64_t val;
+  ::memcpy(&val, chars, sizeof(uint64_t));
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  return val;
+}
+
+#ifdef FASTFLOAT_SSE2
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(const __m128i data) {
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  const __m128i packed = _mm_packus_epi16(data, data);
+#ifdef FASTFLOAT_64BIT
+  return uint64_t(_mm_cvtsi128_si64(packed));
+#else
+  uint64_t value;
+  // Visual Studio + older versions of GCC don't support _mm_storeu_si64
+  _mm_storel_epi64(reinterpret_cast<__m128i *>(&value), packed);
+  return value;
+#endif
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(const char16_t *chars) {
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  return simd_read8_to_u64(
+      _mm_loadu_si128(reinterpret_cast<const __m128i *>(chars)));
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+#elif defined(FASTFLOAT_NEON)
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(const uint16x8_t data) {
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  uint8x8_t utf8_packed = vmovn_u16(data);
+  return vget_lane_u64(vreinterpret_u64_u8(utf8_packed), 0);
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(const char16_t *chars) {
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  return simd_read8_to_u64(
+      vld1q_u16(reinterpret_cast<const uint16_t *>(chars)));
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+#endif // FASTFLOAT_SSE2
+
+// MSVC SFINAE is broken pre-VS2017
+#if defined(_MSC_VER) && _MSC_VER <= 1900
+template <typename UC>
+#else
+template <typename UC, FASTFLOAT_ENABLE_IF(!has_simd_opt<UC>()) = 0>
+#endif
+// dummy for compile
+uint64_t simd_read8_to_u64(UC const *) {
+  return 0;
+}
+
+// credit  @aqrit
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 uint32_t
+parse_eight_digits_unrolled(uint64_t val) {
+  const uint64_t mask = 0x000000FF000000FF;
+  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
+  val -= 0x3030303030303030;
+  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
+  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
+  return uint32_t(val);
+}
+
+// Call this if chars are definitely 8 digits.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint32_t
+parse_eight_digits_unrolled(UC const *chars) noexcept {
+  if (cpp20_and_in_constexpr() || !has_simd_opt<UC>()) {
+    return parse_eight_digits_unrolled(read8_to_u64(chars)); // truncation okay
+  }
+  return parse_eight_digits_unrolled(simd_read8_to_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline constexpr bool
+is_made_of_eight_digits_fast(uint64_t val) noexcept {
+  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+            0x8080808080808080));
+}
+
+#ifdef FASTFLOAT_HAS_SIMD
+
+// Call this if chars might not be 8 digits.
+// Using this style (instead of is_made_of_eight_digits_fast() then
+// parse_eight_digits_unrolled()) ensures we don't load SIMD registers twice.
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 bool
+simd_parse_if_eight_digits_unrolled(const char16_t *chars,
+                                    uint64_t &i) noexcept {
+  if (cpp20_and_in_constexpr()) {
+    return false;
+  }
+#ifdef FASTFLOAT_SSE2
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  const __m128i data =
+      _mm_loadu_si128(reinterpret_cast<const __m128i *>(chars));
+
+  // (x - '0') <= 9
+  // http://0x80.pl/articles/simd-parsing-int-sequences.html
+  const __m128i t0 = _mm_add_epi16(data, _mm_set1_epi16(32720));
+  const __m128i t1 = _mm_cmpgt_epi16(t0, _mm_set1_epi16(-32759));
+
+  if (_mm_movemask_epi8(t1) == 0) {
+    i = i * 100000000 + parse_eight_digits_unrolled(simd_read8_to_u64(data));
+    return true;
+  } else
+    return false;
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+#elif defined(FASTFLOAT_NEON)
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  const uint16x8_t data = vld1q_u16(reinterpret_cast<const uint16_t *>(chars));
+
+  // (x - '0') <= 9
+  // http://0x80.pl/articles/simd-parsing-int-sequences.html
+  const uint16x8_t t0 = vsubq_u16(data, vmovq_n_u16('0'));
+  const uint16x8_t mask = vcltq_u16(t0, vmovq_n_u16('9' - '0' + 1));
+
+  if (vminvq_u16(mask) == 0xFFFF) {
+    i = i * 100000000 + parse_eight_digits_unrolled(simd_read8_to_u64(data));
+    return true;
+  } else
+    return false;
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+#else
+  (void)chars;
+  (void)i;
+  return false;
+#endif // FASTFLOAT_SSE2
+}
+
+#endif // FASTFLOAT_HAS_SIMD
+
+// MSVC SFINAE is broken pre-VS2017
+#if defined(_MSC_VER) && _MSC_VER <= 1900
+template <typename UC>
+#else
+template <typename UC, FASTFLOAT_ENABLE_IF(!has_simd_opt<UC>()) = 0>
+#endif
+// dummy for compile
+bool simd_parse_if_eight_digits_unrolled(UC const *, uint64_t &) {
+  return 0;
+}
+
+template <typename UC, FASTFLOAT_ENABLE_IF(!std::is_same<UC, char>::value) = 0>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+loop_parse_if_eight_digits(const UC *&p, const UC *const pend, uint64_t &i) {
+  if (!has_simd_opt<UC>()) {
+    return;
+  }
+  while ((std::distance(p, pend) >= 8) &&
+         simd_parse_if_eight_digits_unrolled(
+             p, i)) { // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+loop_parse_if_eight_digits(const char *&p, const char *const pend,
+                           uint64_t &i) {
+  // optimizes better than parse_if_eight_digits_unrolled() for UC = char.
+  while ((std::distance(p, pend) >= 8) &&
+         is_made_of_eight_digits_fast(read8_to_u64(p))) {
+    i = i * 100000000 +
+        parse_eight_digits_unrolled(read8_to_u64(
+            p)); // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
+}
+
+enum class parse_error {
+  no_error,
+  // [JSON-only] The minus sign must be followed by an integer.
+  missing_integer_after_sign,
+  // A sign must be followed by an integer or dot.
+  missing_integer_or_dot_after_sign,
+  // [JSON-only] The integer part must not have leading zeros.
+  leading_zeros_in_integer_part,
+  // [JSON-only] The integer part must have at least one digit.
+  no_digits_in_integer_part,
+  // [JSON-only] If there is a decimal point, there must be digits in the
+  // fractional part.
+  no_digits_in_fractional_part,
+  // The mantissa must have at least one digit.
+  no_digits_in_mantissa,
+  // Scientific notation requires an exponential part.
+  missing_exponential_part,
+};
+
+template <typename UC> struct parsed_number_string_t {
+  int64_t exponent{0};
+  uint64_t mantissa{0};
+  UC const *lastmatch{nullptr};
+  bool negative{false};
+  bool valid{false};
+  bool too_many_digits{false};
+  // contains the range of the significant digits
+  span<const UC> integer{};  // non-nullable
+  span<const UC> fraction{}; // nullable
+  parse_error error{parse_error::no_error};
+};
+
+using byte_span = span<const char>;
+using parsed_number_string = parsed_number_string_t<char>;
+
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 parsed_number_string_t<UC>
+report_parse_error(UC const *p, parse_error error) {
+  parsed_number_string_t<UC> answer;
+  answer.valid = false;
+  answer.lastmatch = p;
+  answer.error = error;
+  return answer;
+}
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 parsed_number_string_t<UC>
+parse_number_string(UC const *p, UC const *pend,
+                    parse_options_t<UC> options) noexcept {
+  chars_format const fmt = options.format;
+  UC const decimal_point = options.decimal_point;
+
+  parsed_number_string_t<UC> answer;
+  answer.valid = false;
+  answer.too_many_digits = false;
+  answer.negative = (*p == UC('-'));
+#ifdef FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default
+  if ((*p == UC('-')) || (!(fmt & FASTFLOAT_JSONFMT) && *p == UC('+'))) {
+#else
+  if (*p == UC('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+#endif
+    ++p;
+    if (p == pend) {
+      return report_parse_error<UC>(
+          p, parse_error::missing_integer_or_dot_after_sign);
+    }
+    if (fmt & FASTFLOAT_JSONFMT) {
+      if (!is_integer(*p)) { // a sign must be followed by an integer
+        return report_parse_error<UC>(p,
+                                      parse_error::missing_integer_after_sign);
+      }
+    } else {
+      if (!is_integer(*p) &&
+          (*p !=
+           decimal_point)) { // a sign must be followed by an integer or the dot
+        return report_parse_error<UC>(
+            p, parse_error::missing_integer_or_dot_after_sign);
+      }
+    }
+  }
+  UC const *const start_digits = p;
+
+  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+  while ((p != pend) && is_integer(*p)) {
+    // a multiplication by 10 is cheaper than an arbitrary integer
+    // multiplication
+    i = 10 * i +
+        uint64_t(*p -
+                 UC('0')); // might overflow, we will handle the overflow later
+    ++p;
+  }
+  UC const *const end_of_integer_part = p;
+  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+  answer.integer = span<const UC>(start_digits, size_t(digit_count));
+  if (fmt & FASTFLOAT_JSONFMT) {
+    // at least 1 digit in integer part, without leading zeros
+    if (digit_count == 0) {
+      return report_parse_error<UC>(p, parse_error::no_digits_in_integer_part);
+    }
+    if ((start_digits[0] == UC('0') && digit_count > 1)) {
+      return report_parse_error<UC>(start_digits,
+                                    parse_error::leading_zeros_in_integer_part);
+    }
+  }
+
+  int64_t exponent = 0;
+  const bool has_decimal_point = (p != pend) && (*p == decimal_point);
+  if (has_decimal_point) {
+    ++p;
+    UC const *before = p;
+    // can occur at most twice without overflowing, but let it occur more, since
+    // for integers with many digits, digit parsing is the primary bottleneck.
+    loop_parse_if_eight_digits(p, pend, i);
+
+    while ((p != pend) && is_integer(*p)) {
+      uint8_t digit = uint8_t(*p - UC('0'));
+      ++p;
+      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+    }
+    exponent = before - p;
+    answer.fraction = span<const UC>(before, size_t(p - before));
+    digit_count -= exponent;
+  }
+  if (fmt & FASTFLOAT_JSONFMT) {
+    // at least 1 digit in fractional part
+    if (has_decimal_point && exponent == 0) {
+      return report_parse_error<UC>(p,
+                                    parse_error::no_digits_in_fractional_part);
+    }
+  } else if (digit_count ==
+             0) { // we must have encountered at least one integer!
+    return report_parse_error<UC>(p, parse_error::no_digits_in_mantissa);
+  }
+  int64_t exp_number = 0; // explicit exponential part
+  if (((fmt & chars_format::scientific) && (p != pend) &&
+       ((UC('e') == *p) || (UC('E') == *p))) ||
+      ((fmt & FASTFLOAT_FORTRANFMT) && (p != pend) &&
+       ((UC('+') == *p) || (UC('-') == *p) || (UC('d') == *p) ||
+        (UC('D') == *p)))) {
+    UC const *location_of_e = p;
+    if ((UC('e') == *p) || (UC('E') == *p) || (UC('d') == *p) ||
+        (UC('D') == *p)) {
+      ++p;
+    }
+    bool neg_exp = false;
+    if ((p != pend) && (UC('-') == *p)) {
+      neg_exp = true;
+      ++p;
+    } else if ((p != pend) &&
+               (UC('+') ==
+                *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+      ++p;
+    }
+    if ((p == pend) || !is_integer(*p)) {
+      if (!(fmt & chars_format::fixed)) {
+        // The exponential part is invalid for scientific notation, so it must
+        // be a trailing token for fixed notation. However, fixed notation is
+        // disabled, so report a scientific notation error.
+        return report_parse_error<UC>(p, parse_error::missing_exponential_part);
+      }
+      // Otherwise, we will be ignoring the 'e'.
+      p = location_of_e;
+    } else {
+      while ((p != pend) && is_integer(*p)) {
+        uint8_t digit = uint8_t(*p - UC('0'));
+        if (exp_number < 0x10000000) {
+          exp_number = 10 * exp_number + digit;
+        }
+        ++p;
+      }
+      if (neg_exp) {
+        exp_number = -exp_number;
+      }
+      exponent += exp_number;
+    }
+  } else {
+    // If it scientific and not fixed, we have to bail out.
+    if ((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) {
+      return report_parse_error<UC>(p, parse_error::missing_exponential_part);
+    }
+  }
+  answer.lastmatch = p;
+  answer.valid = true;
+
+  // If we frequently had to deal with long strings of digits,
+  // we could extend our code by using a 128-bit integer instead
+  // of a 64-bit integer. However, this is uncommon.
+  //
+  // We can deal with up to 19 digits.
+  if (digit_count > 19) { // this is uncommon
+    // It is possible that the integer had an overflow.
+    // We have to handle the case where we have 0.0000somenumber.
+    // We need to be mindful of the case where we only have zeroes...
+    // E.g., 0.000000000...000.
+    UC const *start = start_digits;
+    while ((start != pend) && (*start == UC('0') || *start == decimal_point)) {
+      if (*start == UC('0')) {
+        digit_count--;
+      }
+      start++;
+    }
+
+    if (digit_count > 19) {
+      answer.too_many_digits = true;
+      // Let us start again, this time, avoiding overflows.
+      // We don't need to check if is_integer, since we use the
+      // pre-tokenized spans from above.
+      i = 0;
+      p = answer.integer.ptr;
+      UC const *int_end = p + answer.integer.len();
+      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
+      while ((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+        i = i * 10 + uint64_t(*p - UC('0'));
+        ++p;
+      }
+      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+        exponent = end_of_integer_part - p + exp_number;
+      } else { // We have a value with a fractional component.
+        p = answer.fraction.ptr;
+        UC const *frac_end = p + answer.fraction.len();
+        while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+          i = i * 10 + uint64_t(*p - UC('0'));
+          ++p;
+        }
+        exponent = answer.fraction.ptr - p + exp_number;
+      }
+      // We have now corrected both exponent and i, to a truncated value
+    }
+  }
+  answer.exponent = exponent;
+  answer.mantissa = i;
+  return answer;
+}
+
+template <typename T, typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+parse_int_string(UC const *p, UC const *pend, T &value, int base) {
+  from_chars_result_t<UC> answer;
+
+  UC const *const first = p;
+
+  bool negative = (*p == UC('-'));
+  if (!std::is_signed<T>::value && negative) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+#ifdef FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default
+  if ((*p == UC('-')) || (*p == UC('+'))) {
+#else
+  if (*p == UC('-')) {
+#endif
+    ++p;
+  }
+
+  UC const *const start_num = p;
+
+  while (p != pend && *p == UC('0')) {
+    ++p;
+  }
+
+  const bool has_leading_zeros = p > start_num;
+
+  UC const *const start_digits = p;
+
+  uint64_t i = 0;
+  if (base == 10) {
+    loop_parse_if_eight_digits(p, pend, i); // use SIMD if possible
+  }
+  while (p != pend) {
+    uint8_t digit = ch_to_digit(*p);
+    if (digit >= base) {
+      break;
+    }
+    i = uint64_t(base) * i + digit; // might overflow, check this later
+    p++;
+  }
+
+  size_t digit_count = size_t(p - start_digits);
+
+  if (digit_count == 0) {
+    if (has_leading_zeros) {
+      value = 0;
+      answer.ec = std::errc();
+      answer.ptr = p;
+    } else {
+      answer.ec = std::errc::invalid_argument;
+      answer.ptr = first;
+    }
+    return answer;
+  }
+
+  answer.ptr = p;
+
+  // check u64 overflow
+  size_t max_digits = max_digits_u64(base);
+  if (digit_count > max_digits) {
+    answer.ec = std::errc::result_out_of_range;
+    return answer;
+  }
+  // this check can be eliminated for all other types, but they will all require
+  // a max_digits(base) equivalent
+  if (digit_count == max_digits && i < min_safe_u64(base)) {
+    answer.ec = std::errc::result_out_of_range;
+    return answer;
+  }
+
+  // check other types overflow
+  if (!std::is_same<T, uint64_t>::value) {
+    if (i > uint64_t(std::numeric_limits<T>::max()) + uint64_t(negative)) {
+      answer.ec = std::errc::result_out_of_range;
+      return answer;
+    }
+  }
+
+  if (negative) {
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(push)
+#pragma warning(disable : 4146)
+#endif
+    // this weird workaround is required because:
+    // - converting unsigned to signed when its value is greater than signed max
+    // is UB pre-C++23.
+    // - reinterpret_casting (~i + 1) would work, but it is not constexpr
+    // this is always optimized into a neg instruction (note: T is an integer
+    // type)
+    value = T(-std::numeric_limits<T>::max() -
+              T(i - uint64_t(std::numeric_limits<T>::max())));
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(pop)
+#endif
+  } else {
+    value = T(i);
+  }
+
+  answer.ec = std::errc();
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_FAST_TABLE_H
+#define FASTFLOAT_FAST_TABLE_H
+
+#include <cstdint>
+
+namespace fast_float {
+
+/**
+ * When mapping numbers from decimal to binary,
+ * we go from w * 10^q to m * 2^p but we have
+ * 10^q = 5^q * 2^q, so effectively
+ * we are trying to match
+ * w * 2^q * 5^q to m * 2^p. Thus the powers of two
+ * are not a concern since they can be represented
+ * exactly using the binary notation, only the powers of five
+ * affect the binary significand.
+ */
+
+/**
+ * The smallest non-zero float (binary64) is 2^-1074.
+ * We take as input numbers of the form w x 10^q where w < 2^64.
+ * We have that w * 10^-343  <  2^(64-344) 5^-343 < 2^-1076.
+ * However, we have that
+ * (2^64-1) * 10^-342 =  (2^64-1) * 2^-342 * 5^-342 > 2^-1074.
+ * Thus it is possible for a number of the form w * 10^-342 where
+ * w is a 64-bit value to be a non-zero floating-point number.
+ *********
+ * Any number of form w * 10^309 where w>= 1 is going to be
+ * infinite in binary64 so we never need to worry about powers
+ * of 5 greater than 308.
+ */
+template <class unused = void> struct powers_template {
+
+  constexpr static int smallest_power_of_five =
+      binary_format<double>::smallest_power_of_ten();
+  constexpr static int largest_power_of_five =
+      binary_format<double>::largest_power_of_ten();
+  constexpr static int number_of_entries =
+      2 * (largest_power_of_five - smallest_power_of_five + 1);
+  // Powers of five from 5^-342 all the way to 5^308 rounded toward one.
+  constexpr static uint64_t power_of_five_128[number_of_entries] = {
+      0xeef453d6923bd65a, 0x113faa2906a13b3f,
+      0x9558b4661b6565f8, 0x4ac7ca59a424c507,
+      0xbaaee17fa23ebf76, 0x5d79bcf00d2df649,
+      0xe95a99df8ace6f53, 0xf4d82c2c107973dc,
+      0x91d8a02bb6c10594, 0x79071b9b8a4be869,
+      0xb64ec836a47146f9, 0x9748e2826cdee284,
+      0xe3e27a444d8d98b7, 0xfd1b1b2308169b25,
+      0x8e6d8c6ab0787f72, 0xfe30f0f5e50e20f7,
+      0xb208ef855c969f4f, 0xbdbd2d335e51a935,
+      0xde8b2b66b3bc4723, 0xad2c788035e61382,
+      0x8b16fb203055ac76, 0x4c3bcb5021afcc31,
+      0xaddcb9e83c6b1793, 0xdf4abe242a1bbf3d,
+      0xd953e8624b85dd78, 0xd71d6dad34a2af0d,
+      0x87d4713d6f33aa6b, 0x8672648c40e5ad68,
+      0xa9c98d8ccb009506, 0x680efdaf511f18c2,
+      0xd43bf0effdc0ba48, 0x212bd1b2566def2,
+      0x84a57695fe98746d, 0x14bb630f7604b57,
+      0xa5ced43b7e3e9188, 0x419ea3bd35385e2d,
+      0xcf42894a5dce35ea, 0x52064cac828675b9,
+      0x818995ce7aa0e1b2, 0x7343efebd1940993,
+      0xa1ebfb4219491a1f, 0x1014ebe6c5f90bf8,
+      0xca66fa129f9b60a6, 0xd41a26e077774ef6,
+      0xfd00b897478238d0, 0x8920b098955522b4,
+      0x9e20735e8cb16382, 0x55b46e5f5d5535b0,
+      0xc5a890362fddbc62, 0xeb2189f734aa831d,
+      0xf712b443bbd52b7b, 0xa5e9ec7501d523e4,
+      0x9a6bb0aa55653b2d, 0x47b233c92125366e,
+      0xc1069cd4eabe89f8, 0x999ec0bb696e840a,
+      0xf148440a256e2c76, 0xc00670ea43ca250d,
+      0x96cd2a865764dbca, 0x380406926a5e5728,
+      0xbc807527ed3e12bc, 0xc605083704f5ecf2,
+      0xeba09271e88d976b, 0xf7864a44c633682e,
+      0x93445b8731587ea3, 0x7ab3ee6afbe0211d,
+      0xb8157268fdae9e4c, 0x5960ea05bad82964,
+      0xe61acf033d1a45df, 0x6fb92487298e33bd,
+      0x8fd0c16206306bab, 0xa5d3b6d479f8e056,
+      0xb3c4f1ba87bc8696, 0x8f48a4899877186c,
+      0xe0b62e2929aba83c, 0x331acdabfe94de87,
+      0x8c71dcd9ba0b4925, 0x9ff0c08b7f1d0b14,
+      0xaf8e5410288e1b6f, 0x7ecf0ae5ee44dd9,
+      0xdb71e91432b1a24a, 0xc9e82cd9f69d6150,
+      0x892731ac9faf056e, 0xbe311c083a225cd2,
+      0xab70fe17c79ac6ca, 0x6dbd630a48aaf406,
+      0xd64d3d9db981787d, 0x92cbbccdad5b108,
+      0x85f0468293f0eb4e, 0x25bbf56008c58ea5,
+      0xa76c582338ed2621, 0xaf2af2b80af6f24e,
+      0xd1476e2c07286faa, 0x1af5af660db4aee1,
+      0x82cca4db847945ca, 0x50d98d9fc890ed4d,
+      0xa37fce126597973c, 0xe50ff107bab528a0,
+      0xcc5fc196fefd7d0c, 0x1e53ed49a96272c8,
+      0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7a,
+      0x9faacf3df73609b1, 0x77b191618c54e9ac,
+      0xc795830d75038c1d, 0xd59df5b9ef6a2417,
+      0xf97ae3d0d2446f25, 0x4b0573286b44ad1d,
+      0x9becce62836ac577, 0x4ee367f9430aec32,
+      0xc2e801fb244576d5, 0x229c41f793cda73f,
+      0xf3a20279ed56d48a, 0x6b43527578c1110f,
+      0x9845418c345644d6, 0x830a13896b78aaa9,
+      0xbe5691ef416bd60c, 0x23cc986bc656d553,
+      0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa8,
+      0x94b3a202eb1c3f39, 0x7bf7d71432f3d6a9,
+      0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc53,
+      0xe858ad248f5c22c9, 0xd1b3400f8f9cff68,
+      0x91376c36d99995be, 0x23100809b9c21fa1,
+      0xb58547448ffffb2d, 0xabd40a0c2832a78a,
+      0xe2e69915b3fff9f9, 0x16c90c8f323f516c,
+      0x8dd01fad907ffc3b, 0xae3da7d97f6792e3,
+      0xb1442798f49ffb4a, 0x99cd11cfdf41779c,
+      0xdd95317f31c7fa1d, 0x40405643d711d583,
+      0x8a7d3eef7f1cfc52, 0x482835ea666b2572,
+      0xad1c8eab5ee43b66, 0xda3243650005eecf,
+      0xd863b256369d4a40, 0x90bed43e40076a82,
+      0x873e4f75e2224e68, 0x5a7744a6e804a291,
+      0xa90de3535aaae202, 0x711515d0a205cb36,
+      0xd3515c2831559a83, 0xd5a5b44ca873e03,
+      0x8412d9991ed58091, 0xe858790afe9486c2,
+      0xa5178fff668ae0b6, 0x626e974dbe39a872,
+      0xce5d73ff402d98e3, 0xfb0a3d212dc8128f,
+      0x80fa687f881c7f8e, 0x7ce66634bc9d0b99,
+      0xa139029f6a239f72, 0x1c1fffc1ebc44e80,
+      0xc987434744ac874e, 0xa327ffb266b56220,
+      0xfbe9141915d7a922, 0x4bf1ff9f0062baa8,
+      0x9d71ac8fada6c9b5, 0x6f773fc3603db4a9,
+      0xc4ce17b399107c22, 0xcb550fb4384d21d3,
+      0xf6019da07f549b2b, 0x7e2a53a146606a48,
+      0x99c102844f94e0fb, 0x2eda7444cbfc426d,
+      0xc0314325637a1939, 0xfa911155fefb5308,
+      0xf03d93eebc589f88, 0x793555ab7eba27ca,
+      0x96267c7535b763b5, 0x4bc1558b2f3458de,
+      0xbbb01b9283253ca2, 0x9eb1aaedfb016f16,
+      0xea9c227723ee8bcb, 0x465e15a979c1cadc,
+      0x92a1958a7675175f, 0xbfacd89ec191ec9,
+      0xb749faed14125d36, 0xcef980ec671f667b,
+      0xe51c79a85916f484, 0x82b7e12780e7401a,
+      0x8f31cc0937ae58d2, 0xd1b2ecb8b0908810,
+      0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa15,
+      0xdfbdcece67006ac9, 0x67a791e093e1d49a,
+      0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e0,
+      0xaecc49914078536d, 0x58fae9f773886e18,
+      0xda7f5bf590966848, 0xaf39a475506a899e,
+      0x888f99797a5e012d, 0x6d8406c952429603,
+      0xaab37fd7d8f58178, 0xc8e5087ba6d33b83,
+      0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a64,
+      0x855c3be0a17fcd26, 0x5cf2eea09a55067f,
+      0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481e,
+      0xd0601d8efc57b08b, 0xf13b94daf124da26,
+      0x823c12795db6ce57, 0x76c53d08d6b70858,
+      0xa2cb1717b52481ed, 0x54768c4b0c64ca6e,
+      0xcb7ddcdda26da268, 0xa9942f5dcf7dfd09,
+      0xfe5d54150b090b02, 0xd3f93b35435d7c4c,
+      0x9efa548d26e5a6e1, 0xc47bc5014a1a6daf,
+      0xc6b8e9b0709f109a, 0x359ab6419ca1091b,
+      0xf867241c8cc6d4c0, 0xc30163d203c94b62,
+      0x9b407691d7fc44f8, 0x79e0de63425dcf1d,
+      0xc21094364dfb5636, 0x985915fc12f542e4,
+      0xf294b943e17a2bc4, 0x3e6f5b7b17b2939d,
+      0x979cf3ca6cec5b5a, 0xa705992ceecf9c42,
+      0xbd8430bd08277231, 0x50c6ff782a838353,
+      0xece53cec4a314ebd, 0xa4f8bf5635246428,
+      0x940f4613ae5ed136, 0x871b7795e136be99,
+      0xb913179899f68584, 0x28e2557b59846e3f,
+      0xe757dd7ec07426e5, 0x331aeada2fe589cf,
+      0x9096ea6f3848984f, 0x3ff0d2c85def7621,
+      0xb4bca50b065abe63, 0xfed077a756b53a9,
+      0xe1ebce4dc7f16dfb, 0xd3e8495912c62894,
+      0x8d3360f09cf6e4bd, 0x64712dd7abbbd95c,
+      0xb080392cc4349dec, 0xbd8d794d96aacfb3,
+      0xdca04777f541c567, 0xecf0d7a0fc5583a0,
+      0x89e42caaf9491b60, 0xf41686c49db57244,
+      0xac5d37d5b79b6239, 0x311c2875c522ced5,
+      0xd77485cb25823ac7, 0x7d633293366b828b,
+      0x86a8d39ef77164bc, 0xae5dff9c02033197,
+      0xa8530886b54dbdeb, 0xd9f57f830283fdfc,
+      0xd267caa862a12d66, 0xd072df63c324fd7b,
+      0x8380dea93da4bc60, 0x4247cb9e59f71e6d,
+      0xa46116538d0deb78, 0x52d9be85f074e608,
+      0xcd795be870516656, 0x67902e276c921f8b,
+      0x806bd9714632dff6, 0xba1cd8a3db53b6,
+      0xa086cfcd97bf97f3, 0x80e8a40eccd228a4,
+      0xc8a883c0fdaf7df0, 0x6122cd128006b2cd,
+      0xfad2a4b13d1b5d6c, 0x796b805720085f81,
+      0x9cc3a6eec6311a63, 0xcbe3303674053bb0,
+      0xc3f490aa77bd60fc, 0xbedbfc4411068a9c,
+      0xf4f1b4d515acb93b, 0xee92fb5515482d44,
+      0x991711052d8bf3c5, 0x751bdd152d4d1c4a,
+      0xbf5cd54678eef0b6, 0xd262d45a78a0635d,
+      0xef340a98172aace4, 0x86fb897116c87c34,
+      0x9580869f0e7aac0e, 0xd45d35e6ae3d4da0,
+      0xbae0a846d2195712, 0x8974836059cca109,
+      0xe998d258869facd7, 0x2bd1a438703fc94b,
+      0x91ff83775423cc06, 0x7b6306a34627ddcf,
+      0xb67f6455292cbf08, 0x1a3bc84c17b1d542,
+      0xe41f3d6a7377eeca, 0x20caba5f1d9e4a93,
+      0x8e938662882af53e, 0x547eb47b7282ee9c,
+      0xb23867fb2a35b28d, 0xe99e619a4f23aa43,
+      0xdec681f9f4c31f31, 0x6405fa00e2ec94d4,
+      0x8b3c113c38f9f37e, 0xde83bc408dd3dd04,
+      0xae0b158b4738705e, 0x9624ab50b148d445,
+      0xd98ddaee19068c76, 0x3badd624dd9b0957,
+      0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d6,
+      0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4c,
+      0xd47487cc8470652b, 0x7647c3200069671f,
+      0x84c8d4dfd2c63f3b, 0x29ecd9f40041e073,
+      0xa5fb0a17c777cf09, 0xf468107100525890,
+      0xcf79cc9db955c2cc, 0x7182148d4066eeb4,
+      0x81ac1fe293d599bf, 0xc6f14cd848405530,
+      0xa21727db38cb002f, 0xb8ada00e5a506a7c,
+      0xca9cf1d206fdc03b, 0xa6d90811f0e4851c,
+      0xfd442e4688bd304a, 0x908f4a166d1da663,
+      0x9e4a9cec15763e2e, 0x9a598e4e043287fe,
+      0xc5dd44271ad3cdba, 0x40eff1e1853f29fd,
+      0xf7549530e188c128, 0xd12bee59e68ef47c,
+      0x9a94dd3e8cf578b9, 0x82bb74f8301958ce,
+      0xc13a148e3032d6e7, 0xe36a52363c1faf01,
+      0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac1,
+      0x96f5600f15a7b7e5, 0x29ab103a5ef8c0b9,
+      0xbcb2b812db11a5de, 0x7415d448f6b6f0e7,
+      0xebdf661791d60f56, 0x111b495b3464ad21,
+      0x936b9fcebb25c995, 0xcab10dd900beec34,
+      0xb84687c269ef3bfb, 0x3d5d514f40eea742,
+      0xe65829b3046b0afa, 0xcb4a5a3112a5112,
+      0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ab,
+      0xb3f4e093db73a093, 0x59ed216765690f56,
+      0xe0f218b8d25088b8, 0x306869c13ec3532c,
+      0x8c974f7383725573, 0x1e414218c73a13fb,
+      0xafbd2350644eeacf, 0xe5d1929ef90898fa,
+      0xdbac6c247d62a583, 0xdf45f746b74abf39,
+      0x894bc396ce5da772, 0x6b8bba8c328eb783,
+      0xab9eb47c81f5114f, 0x66ea92f3f326564,
+      0xd686619ba27255a2, 0xc80a537b0efefebd,
+      0x8613fd0145877585, 0xbd06742ce95f5f36,
+      0xa798fc4196e952e7, 0x2c48113823b73704,
+      0xd17f3b51fca3a7a0, 0xf75a15862ca504c5,
+      0x82ef85133de648c4, 0x9a984d73dbe722fb,
+      0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebba,
+      0xcc963fee10b7d1b3, 0x318df905079926a8,
+      0xffbbcfe994e5c61f, 0xfdf17746497f7052,
+      0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa633,
+      0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc0,
+      0xf9bd690a1b68637b, 0x3dfdce7aa3c673b0,
+      0x9c1661a651213e2d, 0x6bea10ca65c084e,
+      0xc31bfa0fe5698db8, 0x486e494fcff30a62,
+      0xf3e2f893dec3f126, 0x5a89dba3c3efccfa,
+      0x986ddb5c6b3a76b7, 0xf89629465a75e01c,
+      0xbe89523386091465, 0xf6bbb397f1135823,
+      0xee2ba6c0678b597f, 0x746aa07ded582e2c,
+      0x94db483840b717ef, 0xa8c2a44eb4571cdc,
+      0xba121a4650e4ddeb, 0x92f34d62616ce413,
+      0xe896a0d7e51e1566, 0x77b020baf9c81d17,
+      0x915e2486ef32cd60, 0xace1474dc1d122e,
+      0xb5b5ada8aaff80b8, 0xd819992132456ba,
+      0xe3231912d5bf60e6, 0x10e1fff697ed6c69,
+      0x8df5efabc5979c8f, 0xca8d3ffa1ef463c1,
+      0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb2,
+      0xddd0467c64bce4a0, 0xac7cb3f6d05ddbde,
+      0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96b,
+      0xad4ab7112eb3929d, 0x86c16c98d2c953c6,
+      0xd89d64d57a607744, 0xe871c7bf077ba8b7,
+      0x87625f056c7c4a8b, 0x11471cd764ad4972,
+      0xa93af6c6c79b5d2d, 0xd598e40d3dd89bcf,
+      0xd389b47879823479, 0x4aff1d108d4ec2c3,
+      0x843610cb4bf160cb, 0xcedf722a585139ba,
+      0xa54394fe1eedb8fe, 0xc2974eb4ee658828,
+      0xce947a3da6a9273e, 0x733d226229feea32,
+      0x811ccc668829b887, 0x806357d5a3f525f,
+      0xa163ff802a3426a8, 0xca07c2dcb0cf26f7,
+      0xc9bcff6034c13052, 0xfc89b393dd02f0b5,
+      0xfc2c3f3841f17c67, 0xbbac2078d443ace2,
+      0x9d9ba7832936edc0, 0xd54b944b84aa4c0d,
+      0xc5029163f384a931, 0xa9e795e65d4df11,
+      0xf64335bcf065d37d, 0x4d4617b5ff4a16d5,
+      0x99ea0196163fa42e, 0x504bced1bf8e4e45,
+      0xc06481fb9bcf8d39, 0xe45ec2862f71e1d6,
+      0xf07da27a82c37088, 0x5d767327bb4e5a4c,
+      0x964e858c91ba2655, 0x3a6a07f8d510f86f,
+      0xbbe226efb628afea, 0x890489f70a55368b,
+      0xeadab0aba3b2dbe5, 0x2b45ac74ccea842e,
+      0x92c8ae6b464fc96f, 0x3b0b8bc90012929d,
+      0xb77ada0617e3bbcb, 0x9ce6ebb40173744,
+      0xe55990879ddcaabd, 0xcc420a6a101d0515,
+      0x8f57fa54c2a9eab6, 0x9fa946824a12232d,
+      0xb32df8e9f3546564, 0x47939822dc96abf9,
+      0xdff9772470297ebd, 0x59787e2b93bc56f7,
+      0x8bfbea76c619ef36, 0x57eb4edb3c55b65a,
+      0xaefae51477a06b03, 0xede622920b6b23f1,
+      0xdab99e59958885c4, 0xe95fab368e45eced,
+      0x88b402f7fd75539b, 0x11dbcb0218ebb414,
+      0xaae103b5fcd2a881, 0xd652bdc29f26a119,
+      0xd59944a37c0752a2, 0x4be76d3346f0495f,
+      0x857fcae62d8493a5, 0x6f70a4400c562ddb,
+      0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb952,
+      0xd097ad07a71f26b2, 0x7e2000a41346a7a7,
+      0x825ecc24c873782f, 0x8ed400668c0c28c8,
+      0xa2f67f2dfa90563b, 0x728900802f0f32fa,
+      0xcbb41ef979346bca, 0x4f2b40a03ad2ffb9,
+      0xfea126b7d78186bc, 0xe2f610c84987bfa8,
+      0x9f24b832e6b0f436, 0xdd9ca7d2df4d7c9,
+      0xc6ede63fa05d3143, 0x91503d1c79720dbb,
+      0xf8a95fcf88747d94, 0x75a44c6397ce912a,
+      0x9b69dbe1b548ce7c, 0xc986afbe3ee11aba,
+      0xc24452da229b021b, 0xfbe85badce996168,
+      0xf2d56790ab41c2a2, 0xfae27299423fb9c3,
+      0x97c560ba6b0919a5, 0xdccd879fc967d41a,
+      0xbdb6b8e905cb600f, 0x5400e987bbc1c920,
+      0xed246723473e3813, 0x290123e9aab23b68,
+      0x9436c0760c86e30b, 0xf9a0b6720aaf6521,
+      0xb94470938fa89bce, 0xf808e40e8d5b3e69,
+      0xe7958cb87392c2c2, 0xb60b1d1230b20e04,
+      0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c2,
+      0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af3,
+      0xe2280b6c20dd5232, 0x25c6da63c38de1b0,
+      0x8d590723948a535f, 0x579c487e5a38ad0e,
+      0xb0af48ec79ace837, 0x2d835a9df0c6d851,
+      0xdcdb1b2798182244, 0xf8e431456cf88e65,
+      0x8a08f0f8bf0f156b, 0x1b8e9ecb641b58ff,
+      0xac8b2d36eed2dac5, 0xe272467e3d222f3f,
+      0xd7adf884aa879177, 0x5b0ed81dcc6abb0f,
+      0x86ccbb52ea94baea, 0x98e947129fc2b4e9,
+      0xa87fea27a539e9a5, 0x3f2398d747b36224,
+      0xd29fe4b18e88640e, 0x8eec7f0d19a03aad,
+      0x83a3eeeef9153e89, 0x1953cf68300424ac,
+      0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd7,
+      0xcdb02555653131b6, 0x3792f412cb06794d,
+      0x808e17555f3ebf11, 0xe2bbd88bbee40bd0,
+      0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec4,
+      0xc8de047564d20a8b, 0xf245825a5a445275,
+      0xfb158592be068d2e, 0xeed6e2f0f0d56712,
+      0x9ced737bb6c4183d, 0x55464dd69685606b,
+      0xc428d05aa4751e4c, 0xaa97e14c3c26b886,
+      0xf53304714d9265df, 0xd53dd99f4b3066a8,
+      0x993fe2c6d07b7fab, 0xe546a8038efe4029,
+      0xbf8fdb78849a5f96, 0xde98520472bdd033,
+      0xef73d256a5c0f77c, 0x963e66858f6d4440,
+      0x95a8637627989aad, 0xdde7001379a44aa8,
+      0xbb127c53b17ec159, 0x5560c018580d5d52,
+      0xe9d71b689dde71af, 0xaab8f01e6e10b4a6,
+      0x9226712162ab070d, 0xcab3961304ca70e8,
+      0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d22,
+      0xe45c10c42a2b3b05, 0x8cb89a7db77c506a,
+      0x8eb98a7a9a5b04e3, 0x77f3608e92adb242,
+      0xb267ed1940f1c61c, 0x55f038b237591ed3,
+      0xdf01e85f912e37a3, 0x6b6c46dec52f6688,
+      0x8b61313bbabce2c6, 0x2323ac4b3b3da015,
+      0xae397d8aa96c1b77, 0xabec975e0a0d081a,
+      0xd9c7dced53c72255, 0x96e7bd358c904a21,
+      0x881cea14545c7575, 0x7e50d64177da2e54,
+      0xaa242499697392d2, 0xdde50bd1d5d0b9e9,
+      0xd4ad2dbfc3d07787, 0x955e4ec64b44e864,
+      0x84ec3c97da624ab4, 0xbd5af13bef0b113e,
+      0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58e,
+      0xcfb11ead453994ba, 0x67de18eda5814af2,
+      0x81ceb32c4b43fcf4, 0x80eacf948770ced7,
+      0xa2425ff75e14fc31, 0xa1258379a94d028d,
+      0xcad2f7f5359a3b3e, 0x96ee45813a04330,
+      0xfd87b5f28300ca0d, 0x8bca9d6e188853fc,
+      0x9e74d1b791e07e48, 0x775ea264cf55347e,
+      0xc612062576589dda, 0x95364afe032a819e,
+      0xf79687aed3eec551, 0x3a83ddbd83f52205,
+      0x9abe14cd44753b52, 0xc4926a9672793543,
+      0xc16d9a0095928a27, 0x75b7053c0f178294,
+      0xf1c90080baf72cb1, 0x5324c68b12dd6339,
+      0x971da05074da7bee, 0xd3f6fc16ebca5e04,
+      0xbce5086492111aea, 0x88f4bb1ca6bcf585,
+      0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6,
+      0x9392ee8e921d5d07, 0x3aff322e62439fd0,
+      0xb877aa3236a4b449, 0x9befeb9fad487c3,
+      0xe69594bec44de15b, 0x4c2ebe687989a9b4,
+      0x901d7cf73ab0acd9, 0xf9d37014bf60a11,
+      0xb424dc35095cd80f, 0x538484c19ef38c95,
+      0xe12e13424bb40e13, 0x2865a5f206b06fba,
+      0x8cbccc096f5088cb, 0xf93f87b7442e45d4,
+      0xafebff0bcb24aafe, 0xf78f69a51539d749,
+      0xdbe6fecebdedd5be, 0xb573440e5a884d1c,
+      0x89705f4136b4a597, 0x31680a88f8953031,
+      0xabcc77118461cefc, 0xfdc20d2b36ba7c3e,
+      0xd6bf94d5e57a42bc, 0x3d32907604691b4d,
+      0x8637bd05af6c69b5, 0xa63f9a49c2c1b110,
+      0xa7c5ac471b478423, 0xfcf80dc33721d54,
+      0xd1b71758e219652b, 0xd3c36113404ea4a9,
+      0x83126e978d4fdf3b, 0x645a1cac083126ea,
+      0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4,
+      0xcccccccccccccccc, 0xcccccccccccccccd,
+      0x8000000000000000, 0x0,
+      0xa000000000000000, 0x0,
+      0xc800000000000000, 0x0,
+      0xfa00000000000000, 0x0,
+      0x9c40000000000000, 0x0,
+      0xc350000000000000, 0x0,
+      0xf424000000000000, 0x0,
+      0x9896800000000000, 0x0,
+      0xbebc200000000000, 0x0,
+      0xee6b280000000000, 0x0,
+      0x9502f90000000000, 0x0,
+      0xba43b74000000000, 0x0,
+      0xe8d4a51000000000, 0x0,
+      0x9184e72a00000000, 0x0,
+      0xb5e620f480000000, 0x0,
+      0xe35fa931a0000000, 0x0,
+      0x8e1bc9bf04000000, 0x0,
+      0xb1a2bc2ec5000000, 0x0,
+      0xde0b6b3a76400000, 0x0,
+      0x8ac7230489e80000, 0x0,
+      0xad78ebc5ac620000, 0x0,
+      0xd8d726b7177a8000, 0x0,
+      0x878678326eac9000, 0x0,
+      0xa968163f0a57b400, 0x0,
+      0xd3c21bcecceda100, 0x0,
+      0x84595161401484a0, 0x0,
+      0xa56fa5b99019a5c8, 0x0,
+      0xcecb8f27f4200f3a, 0x0,
+      0x813f3978f8940984, 0x4000000000000000,
+      0xa18f07d736b90be5, 0x5000000000000000,
+      0xc9f2c9cd04674ede, 0xa400000000000000,
+      0xfc6f7c4045812296, 0x4d00000000000000,
+      0x9dc5ada82b70b59d, 0xf020000000000000,
+      0xc5371912364ce305, 0x6c28000000000000,
+      0xf684df56c3e01bc6, 0xc732000000000000,
+      0x9a130b963a6c115c, 0x3c7f400000000000,
+      0xc097ce7bc90715b3, 0x4b9f100000000000,
+      0xf0bdc21abb48db20, 0x1e86d40000000000,
+      0x96769950b50d88f4, 0x1314448000000000,
+      0xbc143fa4e250eb31, 0x17d955a000000000,
+      0xeb194f8e1ae525fd, 0x5dcfab0800000000,
+      0x92efd1b8d0cf37be, 0x5aa1cae500000000,
+      0xb7abc627050305ad, 0xf14a3d9e40000000,
+      0xe596b7b0c643c719, 0x6d9ccd05d0000000,
+      0x8f7e32ce7bea5c6f, 0xe4820023a2000000,
+      0xb35dbf821ae4f38b, 0xdda2802c8a800000,
+      0xe0352f62a19e306e, 0xd50b2037ad200000,
+      0x8c213d9da502de45, 0x4526f422cc340000,
+      0xaf298d050e4395d6, 0x9670b12b7f410000,
+      0xdaf3f04651d47b4c, 0x3c0cdd765f114000,
+      0x88d8762bf324cd0f, 0xa5880a69fb6ac800,
+      0xab0e93b6efee0053, 0x8eea0d047a457a00,
+      0xd5d238a4abe98068, 0x72a4904598d6d880,
+      0x85a36366eb71f041, 0x47a6da2b7f864750,
+      0xa70c3c40a64e6c51, 0x999090b65f67d924,
+      0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d,
+      0x82818f1281ed449f, 0xbff8f10e7a8921a4,
+      0xa321f2d7226895c7, 0xaff72d52192b6a0d,
+      0xcbea6f8ceb02bb39, 0x9bf4f8a69f764490,
+      0xfee50b7025c36a08, 0x2f236d04753d5b4,
+      0x9f4f2726179a2245, 0x1d762422c946590,
+      0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef5,
+      0xf8ebad2b84e0d58b, 0xd2e0898765a7deb2,
+      0x9b934c3b330c8577, 0x63cc55f49f88eb2f,
+      0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fb,
+      0xf316271c7fc3908a, 0x8bef464e3945ef7a,
+      0x97edd871cfda3a56, 0x97758bf0e3cbb5ac,
+      0xbde94e8e43d0c8ec, 0x3d52eeed1cbea317,
+      0xed63a231d4c4fb27, 0x4ca7aaa863ee4bdd,
+      0x945e455f24fb1cf8, 0x8fe8caa93e74ef6a,
+      0xb975d6b6ee39e436, 0xb3e2fd538e122b44,
+      0xe7d34c64a9c85d44, 0x60dbbca87196b616,
+      0x90e40fbeea1d3a4a, 0xbc8955e946fe31cd,
+      0xb51d13aea4a488dd, 0x6babab6398bdbe41,
+      0xe264589a4dcdab14, 0xc696963c7eed2dd1,
+      0x8d7eb76070a08aec, 0xfc1e1de5cf543ca2,
+      0xb0de65388cc8ada8, 0x3b25a55f43294bcb,
+      0xdd15fe86affad912, 0x49ef0eb713f39ebe,
+      0x8a2dbf142dfcc7ab, 0x6e3569326c784337,
+      0xacb92ed9397bf996, 0x49c2c37f07965404,
+      0xd7e77a8f87daf7fb, 0xdc33745ec97be906,
+      0x86f0ac99b4e8dafd, 0x69a028bb3ded71a3,
+      0xa8acd7c0222311bc, 0xc40832ea0d68ce0c,
+      0xd2d80db02aabd62b, 0xf50a3fa490c30190,
+      0x83c7088e1aab65db, 0x792667c6da79e0fa,
+      0xa4b8cab1a1563f52, 0x577001b891185938,
+      0xcde6fd5e09abcf26, 0xed4c0226b55e6f86,
+      0x80b05e5ac60b6178, 0x544f8158315b05b4,
+      0xa0dc75f1778e39d6, 0x696361ae3db1c721,
+      0xc913936dd571c84c, 0x3bc3a19cd1e38e9,
+      0xfb5878494ace3a5f, 0x4ab48a04065c723,
+      0x9d174b2dcec0e47b, 0x62eb0d64283f9c76,
+      0xc45d1df942711d9a, 0x3ba5d0bd324f8394,
+      0xf5746577930d6500, 0xca8f44ec7ee36479,
+      0x9968bf6abbe85f20, 0x7e998b13cf4e1ecb,
+      0xbfc2ef456ae276e8, 0x9e3fedd8c321a67e,
+      0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101e,
+      0x95d04aee3b80ece5, 0xbba1f1d158724a12,
+      0xbb445da9ca61281f, 0x2a8a6e45ae8edc97,
+      0xea1575143cf97226, 0xf52d09d71a3293bd,
+      0x924d692ca61be758, 0x593c2626705f9c56,
+      0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836c,
+      0xe498f455c38b997a, 0xb6dfb9c0f956447,
+      0x8edf98b59a373fec, 0x4724bd4189bd5eac,
+      0xb2977ee300c50fe7, 0x58edec91ec2cb657,
+      0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ed,
+      0x8b865b215899f46c, 0xbd79e0d20082ee74,
+      0xae67f1e9aec07187, 0xecd8590680a3aa11,
+      0xda01ee641a708de9, 0xe80e6f4820cc9495,
+      0x884134fe908658b2, 0x3109058d147fdcdd,
+      0xaa51823e34a7eede, 0xbd4b46f0599fd415,
+      0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91a,
+      0x850fadc09923329e, 0x3e2cf6bc604ddb0,
+      0xa6539930bf6bff45, 0x84db8346b786151c,
+      0xcfe87f7cef46ff16, 0xe612641865679a63,
+      0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07e,
+      0xa26da3999aef7749, 0xe3be5e330f38f09d,
+      0xcb090c8001ab551c, 0x5cadf5bfd3072cc5,
+      0xfdcb4fa002162a63, 0x73d9732fc7c8f7f6,
+      0x9e9f11c4014dda7e, 0x2867e7fddcdd9afa,
+      0xc646d63501a1511d, 0xb281e1fd541501b8,
+      0xf7d88bc24209a565, 0x1f225a7ca91a4226,
+      0x9ae757596946075f, 0x3375788de9b06958,
+      0xc1a12d2fc3978937, 0x52d6b1641c83ae,
+      0xf209787bb47d6b84, 0xc0678c5dbd23a49a,
+      0x9745eb4d50ce6332, 0xf840b7ba963646e0,
+      0xbd176620a501fbff, 0xb650e5a93bc3d898,
+      0xec5d3fa8ce427aff, 0xa3e51f138ab4cebe,
+      0x93ba47c980e98cdf, 0xc66f336c36b10137,
+      0xb8a8d9bbe123f017, 0xb80b0047445d4184,
+      0xe6d3102ad96cec1d, 0xa60dc059157491e5,
+      0x9043ea1ac7e41392, 0x87c89837ad68db2f,
+      0xb454e4a179dd1877, 0x29babe4598c311fb,
+      0xe16a1dc9d8545e94, 0xf4296dd6fef3d67a,
+      0x8ce2529e2734bb1d, 0x1899e4a65f58660c,
+      0xb01ae745b101e9e4, 0x5ec05dcff72e7f8f,
+      0xdc21a1171d42645d, 0x76707543f4fa1f73,
+      0x899504ae72497eba, 0x6a06494a791c53a8,
+      0xabfa45da0edbde69, 0x487db9d17636892,
+      0xd6f8d7509292d603, 0x45a9d2845d3c42b6,
+      0x865b86925b9bc5c2, 0xb8a2392ba45a9b2,
+      0xa7f26836f282b732, 0x8e6cac7768d7141e,
+      0xd1ef0244af2364ff, 0x3207d795430cd926,
+      0x8335616aed761f1f, 0x7f44e6bd49e807b8,
+      0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a6,
+      0xcd036837130890a1, 0x36dba887c37a8c0f,
+      0x802221226be55a64, 0xc2494954da2c9789,
+      0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6c,
+      0xc83553c5c8965d3d, 0x6f92829494e5acc7,
+      0xfa42a8b73abbf48c, 0xcb772339ba1f17f9,
+      0x9c69a97284b578d7, 0xff2a760414536efb,
+      0xc38413cf25e2d70d, 0xfef5138519684aba,
+      0xf46518c2ef5b8cd1, 0x7eb258665fc25d69,
+      0x98bf2f79d5993802, 0xef2f773ffbd97a61,
+      0xbeeefb584aff8603, 0xaafb550ffacfd8fa,
+      0xeeaaba2e5dbf6784, 0x95ba2a53f983cf38,
+      0x952ab45cfa97a0b2, 0xdd945a747bf26183,
+      0xba756174393d88df, 0x94f971119aeef9e4,
+      0xe912b9d1478ceb17, 0x7a37cd5601aab85d,
+      0x91abb422ccb812ee, 0xac62e055c10ab33a,
+      0xb616a12b7fe617aa, 0x577b986b314d6009,
+      0xe39c49765fdf9d94, 0xed5a7e85fda0b80b,
+      0x8e41ade9fbebc27d, 0x14588f13be847307,
+      0xb1d219647ae6b31c, 0x596eb2d8ae258fc8,
+      0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bb,
+      0x8aec23d680043bee, 0x25de7bb9480d5854,
+      0xada72ccc20054ae9, 0xaf561aa79a10ae6a,
+      0xd910f7ff28069da4, 0x1b2ba1518094da04,
+      0x87aa9aff79042286, 0x90fb44d2f05d0842,
+      0xa99541bf57452b28, 0x353a1607ac744a53,
+      0xd3fa922f2d1675f2, 0x42889b8997915ce8,
+      0x847c9b5d7c2e09b7, 0x69956135febada11,
+      0xa59bc234db398c25, 0x43fab9837e699095,
+      0xcf02b2c21207ef2e, 0x94f967e45e03f4bb,
+      0x8161afb94b44f57d, 0x1d1be0eebac278f5,
+      0xa1ba1ba79e1632dc, 0x6462d92a69731732,
+      0xca28a291859bbf93, 0x7d7b8f7503cfdcfe,
+      0xfcb2cb35e702af78, 0x5cda735244c3d43e,
+      0x9defbf01b061adab, 0x3a0888136afa64a7,
+      0xc56baec21c7a1916, 0x88aaa1845b8fdd0,
+      0xf6c69a72a3989f5b, 0x8aad549e57273d45,
+      0x9a3c2087a63f6399, 0x36ac54e2f678864b,
+      0xc0cb28a98fcf3c7f, 0x84576a1bb416a7dd,
+      0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d5,
+      0x969eb7c47859e743, 0x9f644ae5a4b1b325,
+      0xbc4665b596706114, 0x873d5d9f0dde1fee,
+      0xeb57ff22fc0c7959, 0xa90cb506d155a7ea,
+      0x9316ff75dd87cbd8, 0x9a7f12442d588f2,
+      0xb7dcbf5354e9bece, 0xc11ed6d538aeb2f,
+      0xe5d3ef282a242e81, 0x8f1668c8a86da5fa,
+      0x8fa475791a569d10, 0xf96e017d694487bc,
+      0xb38d92d760ec4455, 0x37c981dcc395a9ac,
+      0xe070f78d3927556a, 0x85bbe253f47b1417,
+      0x8c469ab843b89562, 0x93956d7478ccec8e,
+      0xaf58416654a6babb, 0x387ac8d1970027b2,
+      0xdb2e51bfe9d0696a, 0x6997b05fcc0319e,
+      0x88fcf317f22241e2, 0x441fece3bdf81f03,
+      0xab3c2fddeeaad25a, 0xd527e81cad7626c3,
+      0xd60b3bd56a5586f1, 0x8a71e223d8d3b074,
+      0x85c7056562757456, 0xf6872d5667844e49,
+      0xa738c6bebb12d16c, 0xb428f8ac016561db,
+      0xd106f86e69d785c7, 0xe13336d701beba52,
+      0x82a45b450226b39c, 0xecc0024661173473,
+      0xa34d721642b06084, 0x27f002d7f95d0190,
+      0xcc20ce9bd35c78a5, 0x31ec038df7b441f4,
+      0xff290242c83396ce, 0x7e67047175a15271,
+      0x9f79a169bd203e41, 0xf0062c6e984d386,
+      0xc75809c42c684dd1, 0x52c07b78a3e60868,
+      0xf92e0c3537826145, 0xa7709a56ccdf8a82,
+      0x9bbcc7a142b17ccb, 0x88a66076400bb691,
+      0xc2abf989935ddbfe, 0x6acff893d00ea435,
+      0xf356f7ebf83552fe, 0x583f6b8c4124d43,
+      0x98165af37b2153de, 0xc3727a337a8b704a,
+      0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5c,
+      0xeda2ee1c7064130c, 0x1162def06f79df73,
+      0x9485d4d1c63e8be7, 0x8addcb5645ac2ba8,
+      0xb9a74a0637ce2ee1, 0x6d953e2bd7173692,
+      0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0437,
+      0x910ab1d4db9914a0, 0x1d9c9892400a22a2,
+      0xb54d5e4a127f59c8, 0x2503beb6d00cab4b,
+      0xe2a0b5dc971f303a, 0x2e44ae64840fd61d,
+      0x8da471a9de737e24, 0x5ceaecfed289e5d2,
+      0xb10d8e1456105dad, 0x7425a83e872c5f47,
+      0xdd50f1996b947518, 0xd12f124e28f77719,
+      0x8a5296ffe33cc92f, 0x82bd6b70d99aaa6f,
+      0xace73cbfdc0bfb7b, 0x636cc64d1001550b,
+      0xd8210befd30efa5a, 0x3c47f7e05401aa4e,
+      0x8714a775e3e95c78, 0x65acfaec34810a71,
+      0xa8d9d1535ce3b396, 0x7f1839a741a14d0d,
+      0xd31045a8341ca07c, 0x1ede48111209a050,
+      0x83ea2b892091e44d, 0x934aed0aab460432,
+      0xa4e4b66b68b65d60, 0xf81da84d5617853f,
+      0xce1de40642e3f4b9, 0x36251260ab9d668e,
+      0x80d2ae83e9ce78f3, 0xc1d72b7c6b426019,
+      0xa1075a24e4421730, 0xb24cf65b8612f81f,
+      0xc94930ae1d529cfc, 0xdee033f26797b627,
+      0xfb9b7cd9a4a7443c, 0x169840ef017da3b1,
+      0x9d412e0806e88aa5, 0x8e1f289560ee864e,
+      0xc491798a08a2ad4e, 0xf1a6f2bab92a27e2,
+      0xf5b5d7ec8acb58a2, 0xae10af696774b1db,
+      0x9991a6f3d6bf1765, 0xacca6da1e0a8ef29,
+      0xbff610b0cc6edd3f, 0x17fd090a58d32af3,
+      0xeff394dcff8a948e, 0xddfc4b4cef07f5b0,
+      0x95f83d0a1fb69cd9, 0x4abdaf101564f98e,
+      0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f1,
+      0xea53df5fd18d5513, 0x84c86189216dc5ed,
+      0x92746b9be2f8552c, 0x32fd3cf5b4e49bb4,
+      0xb7118682dbb66a77, 0x3fbc8c33221dc2a1,
+      0xe4d5e82392a40515, 0xfabaf3feaa5334a,
+      0x8f05b1163ba6832d, 0x29cb4d87f2a7400e,
+      0xb2c71d5bca9023f8, 0x743e20e9ef511012,
+      0xdf78e4b2bd342cf6, 0x914da9246b255416,
+      0x8bab8eefb6409c1a, 0x1ad089b6c2f7548e,
+      0xae9672aba3d0c320, 0xa184ac2473b529b1,
+      0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741e,
+      0x8865899617fb1871, 0x7e2fa67c7a658892,
+      0xaa7eebfb9df9de8d, 0xddbb901b98feeab7,
+      0xd51ea6fa85785631, 0x552a74227f3ea565,
+      0x8533285c936b35de, 0xd53a88958f87275f,
+      0xa67ff273b8460356, 0x8a892abaf368f137,
+      0xd01fef10a657842c, 0x2d2b7569b0432d85,
+      0x8213f56a67f6b29b, 0x9c3b29620e29fc73,
+      0xa298f2c501f45f42, 0x8349f3ba91b47b8f,
+      0xcb3f2f7642717713, 0x241c70a936219a73,
+      0xfe0efb53d30dd4d7, 0xed238cd383aa0110,
+      0x9ec95d1463e8a506, 0xf4363804324a40aa,
+      0xc67bb4597ce2ce48, 0xb143c6053edcd0d5,
+      0xf81aa16fdc1b81da, 0xdd94b7868e94050a,
+      0x9b10a4e5e9913128, 0xca7cf2b4191c8326,
+      0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f0,
+      0xf24a01a73cf2dccf, 0xbc633b39673c8cec,
+      0x976e41088617ca01, 0xd5be0503e085d813,
+      0xbd49d14aa79dbc82, 0x4b2d8644d8a74e18,
+      0xec9c459d51852ba2, 0xddf8e7d60ed1219e,
+      0x93e1ab8252f33b45, 0xcabb90e5c942b503,
+      0xb8da1662e7b00a17, 0x3d6a751f3b936243,
+      0xe7109bfba19c0c9d, 0xcc512670a783ad4,
+      0x906a617d450187e2, 0x27fb2b80668b24c5,
+      0xb484f9dc9641e9da, 0xb1f9f660802dedf6,
+      0xe1a63853bbd26451, 0x5e7873f8a0396973,
+      0x8d07e33455637eb2, 0xdb0b487b6423e1e8,
+      0xb049dc016abc5e5f, 0x91ce1a9a3d2cda62,
+      0xdc5c5301c56b75f7, 0x7641a140cc7810fb,
+      0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9d,
+      0xac2820d9623bf429, 0x546345fa9fbdcd44,
+      0xd732290fbacaf133, 0xa97c177947ad4095,
+      0x867f59a9d4bed6c0, 0x49ed8eabcccc485d,
+      0xa81f301449ee8c70, 0x5c68f256bfff5a74,
+      0xd226fc195c6a2f8c, 0x73832eec6fff3111,
+      0x83585d8fd9c25db7, 0xc831fd53c5ff7eab,
+      0xa42e74f3d032f525, 0xba3e7ca8b77f5e55,
+      0xcd3a1230c43fb26f, 0x28ce1bd2e55f35eb,
+      0x80444b5e7aa7cf85, 0x7980d163cf5b81b3,
+      0xa0555e361951c366, 0xd7e105bcc332621f,
+      0xc86ab5c39fa63440, 0x8dd9472bf3fefaa7,
+      0xfa856334878fc150, 0xb14f98f6f0feb951,
+      0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d3,
+      0xc3b8358109e84f07, 0xa862f80ec4700c8,
+      0xf4a642e14c6262c8, 0xcd27bb612758c0fa,
+      0x98e7e9cccfbd7dbd, 0x8038d51cb897789c,
+      0xbf21e44003acdd2c, 0xe0470a63e6bd56c3,
+      0xeeea5d5004981478, 0x1858ccfce06cac74,
+      0x95527a5202df0ccb, 0xf37801e0c43ebc8,
+      0xbaa718e68396cffd, 0xd30560258f54e6ba,
+      0xe950df20247c83fd, 0x47c6b82ef32a2069,
+      0x91d28b7416cdd27e, 0x4cdc331d57fa5441,
+      0xb6472e511c81471d, 0xe0133fe4adf8e952,
+      0xe3d8f9e563a198e5, 0x58180fddd97723a6,
+      0x8e679c2f5e44ff8f, 0x570f09eaa7ea7648,
+  };
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <class unused>
+constexpr uint64_t
+    powers_template<unused>::power_of_five_128[number_of_entries];
+
+#endif
+
+using powers = powers_template<>;
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_DECIMAL_TO_BINARY_H
+#define FASTFLOAT_DECIMAL_TO_BINARY_H
+
+#include <cfloat>
+#include <cinttypes>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+
+namespace fast_float {
+
+// This will compute or rather approximate w * 5**q and return a pair of 64-bit
+// words approximating the result, with the "high" part corresponding to the
+// most significant bits and the low part corresponding to the least significant
+// bits.
+//
+template <int bit_precision>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 value128
+compute_product_approximation(int64_t q, uint64_t w) {
+  const int index = 2 * int(q - powers::smallest_power_of_five);
+  // For small values of q, e.g., q in [0,27], the answer is always exact
+  // because The line value128 firstproduct = full_multiplication(w,
+  // power_of_five_128[index]); gives the exact answer.
+  value128 firstproduct =
+      full_multiplication(w, powers::power_of_five_128[index]);
+  static_assert((bit_precision >= 0) && (bit_precision <= 64),
+                " precision should  be in (0,64]");
+  constexpr uint64_t precision_mask =
+      (bit_precision < 64) ? (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
+                           : uint64_t(0xFFFFFFFFFFFFFFFF);
+  if ((firstproduct.high & precision_mask) ==
+      precision_mask) { // could further guard with  (lower + w < lower)
+    // regarding the second product, we only need secondproduct.high, but our
+    // expectation is that the compiler will optimize this extra work away if
+    // needed.
+    value128 secondproduct =
+        full_multiplication(w, powers::power_of_five_128[index + 1]);
+    firstproduct.low += secondproduct.high;
+    if (secondproduct.high > firstproduct.low) {
+      firstproduct.high++;
+    }
+  }
+  return firstproduct;
+}
+
+namespace detail {
+/**
+ * For q in (0,350), we have that
+ *  f = (((152170 + 65536) * q ) >> 16);
+ * is equal to
+ *   floor(p) + q
+ * where
+ *   p = log(5**q)/log(2) = q * log(5)/log(2)
+ *
+ * For negative values of q in (-400,0), we have that
+ *  f = (((152170 + 65536) * q ) >> 16);
+ * is equal to
+ *   -ceil(p) + q
+ * where
+ *   p = log(5**-q)/log(2) = -q * log(5)/log(2)
+ */
+constexpr fastfloat_really_inline int32_t power(int32_t q) noexcept {
+  return (((152170 + 65536) * q) >> 16) + 63;
+}
+} // namespace detail
+
+// create an adjusted mantissa, biased by the invalid power2
+// for significant digits already multiplied by 10 ** q.
+template <typename binary>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 adjusted_mantissa
+compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept {
+  int hilz = int(w >> 63) ^ 1;
+  adjusted_mantissa answer;
+  answer.mantissa = w << hilz;
+  int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
+  answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 +
+                          invalid_am_bias);
+  return answer;
+}
+
+// w * 10 ** q, without rounding the representation up.
+// the power2 in the exponent will be adjusted by invalid_am_bias.
+template <typename binary>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+compute_error(int64_t q, uint64_t w) noexcept {
+  int lz = leading_zeroes(w);
+  w <<= lz;
+  value128 product =
+      compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  return compute_error_scaled<binary>(q, product.high, lz);
+}
+
+// w * 10 ** q
+// The returned value should be a valid ieee64 number that simply need to be
+// packed. However, in some very rare cases, the computation will fail. In such
+// cases, we return an adjusted_mantissa with a negative power of 2: the caller
+// should recompute in such cases.
+template <typename binary>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+compute_float(int64_t q, uint64_t w) noexcept {
+  adjusted_mantissa answer;
+  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
+    answer.power2 = 0;
+    answer.mantissa = 0;
+    // result should be zero
+    return answer;
+  }
+  if (q > binary::largest_power_of_ten()) {
+    // we want to get infinity:
+    answer.power2 = binary::infinite_power();
+    answer.mantissa = 0;
+    return answer;
+  }
+  // At this point in time q is in [powers::smallest_power_of_five,
+  // powers::largest_power_of_five].
+
+  // We want the most significant bit of i to be 1. Shift if needed.
+  int lz = leading_zeroes(w);
+  w <<= lz;
+
+  // The required precision is binary::mantissa_explicit_bits() + 3 because
+  // 1. We need the implicit bit
+  // 2. We need an extra bit for rounding purposes
+  // 3. We might lose a bit due to the "upperbit" routine (result too small,
+  // requiring a shift)
+
+  value128 product =
+      compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  // The computed 'product' is always sufficient.
+  // Mathematical proof:
+  // Noble Mushtak and Daniel Lemire, Fast Number Parsing Without Fallback (to
+  // appear) See script/mushtak_lemire.py
+
+  // The "compute_product_approximation" function can be slightly slower than a
+  // branchless approach: value128 product = compute_product(q, w); but in
+  // practice, we can win big with the compute_product_approximation if its
+  // additional branch is easily predicted. Which is best is data specific.
+  int upperbit = int(product.high >> 63);
+  int shift = upperbit + 64 - binary::mantissa_explicit_bits() - 3;
+
+  answer.mantissa = product.high >> shift;
+
+  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz -
+                          binary::minimum_exponent());
+  if (answer.power2 <= 0) { // we have a subnormal?
+    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
+    if (-answer.power2 + 1 >=
+        64) { // if we have more than 64 bits below the minimum exponent, you
+              // have a zero for sure.
+      answer.power2 = 0;
+      answer.mantissa = 0;
+      // result should be zero
+      return answer;
+    }
+    // next line is safe because -answer.power2 + 1 < 64
+    answer.mantissa >>= -answer.power2 + 1;
+    // Thankfully, we can't have both "round-to-even" and subnormals because
+    // "round-to-even" only occurs for powers close to 0.
+    answer.mantissa += (answer.mantissa & 1); // round up
+    answer.mantissa >>= 1;
+    // There is a weird scenario where we don't have a subnormal but just.
+    // Suppose we start with 2.2250738585072013e-308, we end up
+    // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
+    // whereas 0x40000000000000 x 2^-1023-53  is normal. Now, we need to round
+    // up 0x3fffffffffffff x 2^-1023-53  and once we do, we are no longer
+    // subnormal, but we can only know this after rounding.
+    // So we only declare a subnormal if we are smaller than the threshold.
+    answer.power2 =
+        (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits()))
+            ? 0
+            : 1;
+    return answer;
+  }
+
+  // usually, we round *up*, but if we fall right in between and and we have an
+  // even basis, we need to round down
+  // We are only concerned with the cases where 5**q fits in single 64-bit word.
+  if ((product.low <= 1) && (q >= binary::min_exponent_round_to_even()) &&
+      (q <= binary::max_exponent_round_to_even()) &&
+      ((answer.mantissa & 3) == 1)) { // we may fall between two floats!
+    // To be in-between two floats we need that in doing
+    //   answer.mantissa = product.high >> (upperbit + 64 -
+    //   binary::mantissa_explicit_bits() - 3);
+    // ... we dropped out only zeroes. But if this happened, then we can go
+    // back!!!
+    if ((answer.mantissa << shift) == product.high) {
+      answer.mantissa &= ~uint64_t(1); // flip it so that we do not round up
+    }
+  }
+
+  answer.mantissa += (answer.mantissa & 1); // round up
+  answer.mantissa >>= 1;
+  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
+    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
+    answer.power2++; // undo previous addition
+  }
+
+  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
+  if (answer.power2 >= binary::infinite_power()) { // infinity
+    answer.power2 = binary::infinite_power();
+    answer.mantissa = 0;
+  }
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_BIGINT_H
+#define FASTFLOAT_BIGINT_H
+
+#include <algorithm>
+#include <cstdint>
+#include <climits>
+#include <cstring>
+
+
+namespace fast_float {
+
+// the limb width: we want efficient multiplication of double the bits in
+// limb, or for 64-bit limbs, at least 64-bit multiplication where we can
+// extract the high and low parts efficiently. this is every 64-bit
+// architecture except for sparc, which emulates 128-bit multiplication.
+// we might have platforms where `CHAR_BIT` is not 8, so let's avoid
+// doing `8 * sizeof(limb)`.
+#if defined(FASTFLOAT_64BIT) && !defined(__sparc)
+#define FASTFLOAT_64BIT_LIMB 1
+typedef uint64_t limb;
+constexpr size_t limb_bits = 64;
+#else
+#define FASTFLOAT_32BIT_LIMB
+typedef uint32_t limb;
+constexpr size_t limb_bits = 32;
+#endif
+
+typedef span<limb> limb_span;
+
+// number of bits in a bigint. this needs to be at least the number
+// of bits required to store the largest bigint, which is
+// `log2(10**(digits + max_exp))`, or `log2(10**(767 + 342))`, or
+// ~3600 bits, so we round to 4000.
+constexpr size_t bigint_bits = 4000;
+constexpr size_t bigint_limbs = bigint_bits / limb_bits;
+
+// vector-like type that is allocated on the stack. the entire
+// buffer is pre-allocated, and only the length changes.
+template <uint16_t size> struct stackvec {
+  limb data[size];
+  // we never need more than 150 limbs
+  uint16_t length{0};
+
+  stackvec() = default;
+  stackvec(const stackvec &) = delete;
+  stackvec &operator=(const stackvec &) = delete;
+  stackvec(stackvec &&) = delete;
+  stackvec &operator=(stackvec &&other) = delete;
+
+  // create stack vector from existing limb span.
+  FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) {
+    FASTFLOAT_ASSERT(try_extend(s));
+  }
+
+  FASTFLOAT_CONSTEXPR14 limb &operator[](size_t index) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+  FASTFLOAT_CONSTEXPR14 const limb &operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+  // index from the end of the container
+  FASTFLOAT_CONSTEXPR14 const limb &rindex(size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    size_t rindex = length - index - 1;
+    return data[rindex];
+  }
+
+  // set the length, without bounds checking.
+  FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept {
+    length = uint16_t(len);
+  }
+  constexpr size_t len() const noexcept { return length; }
+  constexpr bool is_empty() const noexcept { return length == 0; }
+  constexpr size_t capacity() const noexcept { return size; }
+  // append item to vector, without bounds checking
+  FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept {
+    data[length] = value;
+    length++;
+  }
+  // append item to vector, returning if item was added
+  FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept {
+    if (len() < capacity()) {
+      push_unchecked(value);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // add items to the vector, from a span, without bounds checking
+  FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept {
+    limb *ptr = data + length;
+    std::copy_n(s.ptr, s.len(), ptr);
+    set_len(len() + s.len());
+  }
+  // try to add items to the vector, returning if items were added
+  FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept {
+    if (len() + s.len() <= capacity()) {
+      extend_unchecked(s);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // resize the vector, without bounds checking
+  // if the new size is longer than the vector, assign value to each
+  // appended item.
+  FASTFLOAT_CONSTEXPR20
+  void resize_unchecked(size_t new_len, limb value) noexcept {
+    if (new_len > len()) {
+      size_t count = new_len - len();
+      limb *first = data + len();
+      limb *last = first + count;
+      ::std::fill(first, last, value);
+      set_len(new_len);
+    } else {
+      set_len(new_len);
+    }
+  }
+  // try to resize the vector, returning if the vector was resized.
+  FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept {
+    if (new_len > capacity()) {
+      return false;
+    } else {
+      resize_unchecked(new_len, value);
+      return true;
+    }
+  }
+  // check if any limbs are non-zero after the given index.
+  // this needs to be done in reverse order, since the index
+  // is relative to the most significant limbs.
+  FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept {
+    while (index < len()) {
+      if (rindex(index) != 0) {
+        return true;
+      }
+      index++;
+    }
+    return false;
+  }
+  // normalize the big integer, so most-significant zero limbs are removed.
+  FASTFLOAT_CONSTEXPR14 void normalize() noexcept {
+    while (len() > 0 && rindex(0) == 0) {
+      length--;
+    }
+  }
+};
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 uint64_t
+empty_hi64(bool &truncated) noexcept {
+  truncated = false;
+  return 0;
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint64_t
+uint64_hi64(uint64_t r0, bool &truncated) noexcept {
+  truncated = false;
+  int shl = leading_zeroes(r0);
+  return r0 << shl;
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint64_t
+uint64_hi64(uint64_t r0, uint64_t r1, bool &truncated) noexcept {
+  int shl = leading_zeroes(r0);
+  if (shl == 0) {
+    truncated = r1 != 0;
+    return r0;
+  } else {
+    int shr = 64 - shl;
+    truncated = (r1 << shl) != 0;
+    return (r0 << shl) | (r1 >> shr);
+  }
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint64_t
+uint32_hi64(uint32_t r0, bool &truncated) noexcept {
+  return uint64_hi64(r0, truncated);
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint64_t
+uint32_hi64(uint32_t r0, uint32_t r1, bool &truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  return uint64_hi64((x0 << 32) | x1, truncated);
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint64_t
+uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool &truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  uint64_t x2 = r2;
+  return uint64_hi64(x0, (x1 << 32) | x2, truncated);
+}
+
+// add two small integers, checking for overflow.
+// we want an efficient operation. for msvc, where
+// we don't have built-in intrinsics, this is still
+// pretty fast.
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 limb
+scalar_add(limb x, limb y, bool &overflow) noexcept {
+  limb z;
+// gcc and clang
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_add_overflow)
+  if (!cpp20_and_in_constexpr()) {
+    overflow = __builtin_add_overflow(x, y, &z);
+    return z;
+  }
+#endif
+#endif
+
+  // generic, this still optimizes correctly on MSVC.
+  z = x + y;
+  overflow = z < x;
+  return z;
+}
+
+// multiply two small integers, getting both the high and low bits.
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 limb
+scalar_mul(limb x, limb y, limb &carry) noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+#if defined(__SIZEOF_INT128__)
+  // GCC and clang both define it as an extension.
+  __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+#else
+  // fallback, no native 128-bit integer multiplication with carry.
+  // on msvc, this optimizes identically, somehow.
+  value128 z = full_multiplication(x, y);
+  bool overflow;
+  z.low = scalar_add(z.low, carry, overflow);
+  z.high += uint64_t(overflow); // cannot overflow
+  carry = z.high;
+  return z.low;
+#endif
+#else
+  uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+#endif
+}
+
+// add scalar value to bigint starting from offset.
+// used in grade school multiplication
+template <uint16_t size>
+inline FASTFLOAT_CONSTEXPR20 bool small_add_from(stackvec<size> &vec, limb y,
+                                                 size_t start) noexcept {
+  size_t index = start;
+  limb carry = y;
+  bool overflow;
+  while (carry != 0 && index < vec.len()) {
+    vec[index] = scalar_add(vec[index], carry, overflow);
+    carry = limb(overflow);
+    index += 1;
+  }
+  if (carry != 0) {
+    FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add scalar value to bigint.
+template <uint16_t size>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 bool
+small_add(stackvec<size> &vec, limb y) noexcept {
+  return small_add_from(vec, y, 0);
+}
+
+// multiply bigint by scalar value.
+template <uint16_t size>
+inline FASTFLOAT_CONSTEXPR20 bool small_mul(stackvec<size> &vec,
+                                            limb y) noexcept {
+  limb carry = 0;
+  for (size_t index = 0; index < vec.len(); index++) {
+    vec[index] = scalar_mul(vec[index], y, carry);
+  }
+  if (carry != 0) {
+    FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add bigint to bigint starting from index.
+// used in grade school multiplication
+template <uint16_t size>
+FASTFLOAT_CONSTEXPR20 bool large_add_from(stackvec<size> &x, limb_span y,
+                                          size_t start) noexcept {
+  // the effective x buffer is from `xstart..x.len()`, so exit early
+  // if we can't get that current range.
+  if (x.len() < start || y.len() > x.len() - start) {
+    FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
+  }
+
+  bool carry = false;
+  for (size_t index = 0; index < y.len(); index++) {
+    limb xi = x[index + start];
+    limb yi = y[index];
+    bool c1 = false;
+    bool c2 = false;
+    xi = scalar_add(xi, yi, c1);
+    if (carry) {
+      xi = scalar_add(xi, 1, c2);
+    }
+    x[index + start] = xi;
+    carry = c1 | c2;
+  }
+
+  // handle overflow
+  if (carry) {
+    FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start));
+  }
+  return true;
+}
+
+// add bigint to bigint.
+template <uint16_t size>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 bool
+large_add_from(stackvec<size> &x, limb_span y) noexcept {
+  return large_add_from(x, y, 0);
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+FASTFLOAT_CONSTEXPR20 bool long_mul(stackvec<size> &x, limb_span y) noexcept {
+  limb_span xs = limb_span(x.data, x.len());
+  stackvec<size> z(xs);
+  limb_span zs = limb_span(z.data, z.len());
+
+  if (y.len() != 0) {
+    limb y0 = y[0];
+    FASTFLOAT_TRY(small_mul(x, y0));
+    for (size_t index = 1; index < y.len(); index++) {
+      limb yi = y[index];
+      stackvec<size> zi;
+      if (yi != 0) {
+        // re-use the same buffer throughout
+        zi.set_len(0);
+        FASTFLOAT_TRY(zi.try_extend(zs));
+        FASTFLOAT_TRY(small_mul(zi, yi));
+        limb_span zis = limb_span(zi.data, zi.len());
+        FASTFLOAT_TRY(large_add_from(x, zis, index));
+      }
+    }
+  }
+
+  x.normalize();
+  return true;
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+FASTFLOAT_CONSTEXPR20 bool large_mul(stackvec<size> &x, limb_span y) noexcept {
+  if (y.len() == 1) {
+    FASTFLOAT_TRY(small_mul(x, y[0]));
+  } else {
+    FASTFLOAT_TRY(long_mul(x, y));
+  }
+  return true;
+}
+
+template <typename = void> struct pow5_tables {
+  static constexpr uint32_t large_step = 135;
+  static constexpr uint64_t small_power_of_5[] = {
+      1UL,
+      5UL,
+      25UL,
+      125UL,
+      625UL,
+      3125UL,
+      15625UL,
+      78125UL,
+      390625UL,
+      1953125UL,
+      9765625UL,
+      48828125UL,
+      244140625UL,
+      1220703125UL,
+      6103515625UL,
+      30517578125UL,
+      152587890625UL,
+      762939453125UL,
+      3814697265625UL,
+      19073486328125UL,
+      95367431640625UL,
+      476837158203125UL,
+      2384185791015625UL,
+      11920928955078125UL,
+      59604644775390625UL,
+      298023223876953125UL,
+      1490116119384765625UL,
+      7450580596923828125UL,
+  };
+#ifdef FASTFLOAT_64BIT_LIMB
+  constexpr static limb large_power_of_5[] = {
+      1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
+      10482974169319127550UL, 198276706040285095UL};
+#else
+  constexpr static limb large_power_of_5[] = {
+      4279965485U, 329373468U,  4020270615U, 2137533757U, 4287402176U,
+      1057042919U, 1071430142U, 2440757623U, 381945767U,  46164893U};
+#endif
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr uint32_t pow5_tables<T>::large_step;
+
+template <typename T> constexpr uint64_t pow5_tables<T>::small_power_of_5[];
+
+template <typename T> constexpr limb pow5_tables<T>::large_power_of_5[];
+
+#endif
+
+// big integer type. implements a small subset of big integer
+// arithmetic, using simple algorithms since asymptotically
+// faster algorithms are slower for a small number of limbs.
+// all operations assume the big-integer is normalized.
+struct bigint : pow5_tables<> {
+  // storage of the limbs, in little-endian order.
+  stackvec<bigint_limbs> vec;
+
+  FASTFLOAT_CONSTEXPR20 bigint() : vec() {}
+  bigint(const bigint &) = delete;
+  bigint &operator=(const bigint &) = delete;
+  bigint(bigint &&) = delete;
+  bigint &operator=(bigint &&other) = delete;
+
+  FASTFLOAT_CONSTEXPR20 bigint(uint64_t value) : vec() {
+#ifdef FASTFLOAT_64BIT_LIMB
+    vec.push_unchecked(value);
+#else
+    vec.push_unchecked(uint32_t(value));
+    vec.push_unchecked(uint32_t(value >> 32));
+#endif
+    vec.normalize();
+  }
+
+  // get the high 64 bits from the vector, and if bits were truncated.
+  // this is to get the significant digits for the float.
+  FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool &truncated) const noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint64_hi64(vec.rindex(0), truncated);
+    } else {
+      uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
+      truncated |= vec.nonzero(2);
+      return result;
+    }
+#else
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint32_hi64(vec.rindex(0), truncated);
+    } else if (vec.len() == 2) {
+      return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated);
+    } else {
+      uint64_t result =
+          uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated);
+      truncated |= vec.nonzero(3);
+      return result;
+    }
+#endif
+  }
+
+  // compare two big integers, returning the large value.
+  // assumes both are normalized. if the return value is
+  // negative, other is larger, if the return value is
+  // positive, this is larger, otherwise they are equal.
+  // the limbs are stored in little-endian order, so we
+  // must compare the limbs in ever order.
+  FASTFLOAT_CONSTEXPR20 int compare(const bigint &other) const noexcept {
+    if (vec.len() > other.vec.len()) {
+      return 1;
+    } else if (vec.len() < other.vec.len()) {
+      return -1;
+    } else {
+      for (size_t index = vec.len(); index > 0; index--) {
+        limb xi = vec[index - 1];
+        limb yi = other.vec[index - 1];
+        if (xi > yi) {
+          return 1;
+        } else if (xi < yi) {
+          return -1;
+        }
+      }
+      return 0;
+    }
+  }
+
+  // shift left each limb n bits, carrying over to the new limb
+  // returns true if we were able to shift all the digits.
+  FASTFLOAT_CONSTEXPR20 bool shl_bits(size_t n) noexcept {
+    // Internally, for each item, we shift left by n, and add the previous
+    // right shifted limb-bits.
+    // For example, we transform (for u8) shifted left 2, to:
+    //      b10100100 b01000010
+    //      b10 b10010001 b00001000
+    FASTFLOAT_DEBUG_ASSERT(n != 0);
+    FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
+
+    size_t shl = n;
+    size_t shr = limb_bits - shl;
+    limb prev = 0;
+    for (size_t index = 0; index < vec.len(); index++) {
+      limb xi = vec[index];
+      vec[index] = (xi << shl) | (prev >> shr);
+      prev = xi;
+    }
+
+    limb carry = prev >> shr;
+    if (carry != 0) {
+      return vec.try_push(carry);
+    }
+    return true;
+  }
+
+  // move the limbs left by `n` limbs.
+  FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(n != 0);
+    if (n + vec.len() > vec.capacity()) {
+      return false;
+    } else if (!vec.is_empty()) {
+      // move limbs
+      limb *dst = vec.data + n;
+      const limb *src = vec.data;
+      std::copy_backward(src, src + vec.len(), dst + vec.len());
+      // fill in empty limbs
+      limb *first = vec.data;
+      limb *last = first + n;
+      ::std::fill(first, last, 0);
+      vec.set_len(n + vec.len());
+      return true;
+    } else {
+      return true;
+    }
+  }
+
+  // move the limbs left by `n` bits.
+  FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept {
+    size_t rem = n % limb_bits;
+    size_t div = n / limb_bits;
+    if (rem != 0) {
+      FASTFLOAT_TRY(shl_bits(rem));
+    }
+    if (div != 0) {
+      FASTFLOAT_TRY(shl_limbs(div));
+    }
+    return true;
+  }
+
+  // get the number of leading zeros in the bigint.
+  FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept {
+    if (vec.is_empty()) {
+      return 0;
+    } else {
+#ifdef FASTFLOAT_64BIT_LIMB
+      return leading_zeroes(vec.rindex(0));
+#else
+      // no use defining a specialized leading_zeroes for a 32-bit type.
+      uint64_t r0 = vec.rindex(0);
+      return leading_zeroes(r0 << 32);
+#endif
+    }
+  }
+
+  // get the number of bits in the bigint.
+  FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept {
+    int lz = ctlz();
+    return int(limb_bits * vec.len()) - lz;
+  }
+
+  FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { return small_mul(vec, y); }
+
+  FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { return small_add(vec, y); }
+
+  // multiply as if by 2 raised to a power.
+  FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); }
+
+  // multiply as if by 5 raised to a power.
+  FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept {
+    // multiply by a power of 5
+    size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
+    limb_span large = limb_span(large_power_of_5, large_length);
+    while (exp >= large_step) {
+      FASTFLOAT_TRY(large_mul(vec, large));
+      exp -= large_step;
+    }
+#ifdef FASTFLOAT_64BIT_LIMB
+    uint32_t small_step = 27;
+    limb max_native = 7450580596923828125UL;
+#else
+    uint32_t small_step = 13;
+    limb max_native = 1220703125U;
+#endif
+    while (exp >= small_step) {
+      FASTFLOAT_TRY(small_mul(vec, max_native));
+      exp -= small_step;
+    }
+    if (exp != 0) {
+      // Work around clang bug https://godbolt.org/z/zedh7rrhc
+      // This is similar to https://github.com/llvm/llvm-project/issues/47746,
+      // except the workaround described there don't work here
+      FASTFLOAT_TRY(small_mul(
+          vec, limb(((void)small_power_of_5[0], small_power_of_5[exp]))));
+    }
+
+    return true;
+  }
+
+  // multiply as if by 10 raised to a power.
+  FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept {
+    FASTFLOAT_TRY(pow5(exp));
+    return pow2(exp);
+  }
+};
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_DIGIT_COMPARISON_H
+#define FASTFLOAT_DIGIT_COMPARISON_H
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+
+namespace fast_float {
+
+// 1e0 to 1e19
+constexpr static uint64_t powers_of_ten_uint64[] = {1UL,
+                                                    10UL,
+                                                    100UL,
+                                                    1000UL,
+                                                    10000UL,
+                                                    100000UL,
+                                                    1000000UL,
+                                                    10000000UL,
+                                                    100000000UL,
+                                                    1000000000UL,
+                                                    10000000000UL,
+                                                    100000000000UL,
+                                                    1000000000000UL,
+                                                    10000000000000UL,
+                                                    100000000000000UL,
+                                                    1000000000000000UL,
+                                                    10000000000000000UL,
+                                                    100000000000000000UL,
+                                                    1000000000000000000UL,
+                                                    10000000000000000000UL};
+
+// calculate the exponent, in scientific notation, of the number.
+// this algorithm is not even close to optimized, but it has no practical
+// effect on performance: in order to have a faster algorithm, we'd need
+// to slow down performance for faster algorithms, and this is still fast.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 int32_t
+scientific_exponent(parsed_number_string_t<UC> &num) noexcept {
+  uint64_t mantissa = num.mantissa;
+  int32_t exponent = int32_t(num.exponent);
+  while (mantissa >= 10000) {
+    mantissa /= 10000;
+    exponent += 4;
+  }
+  while (mantissa >= 100) {
+    mantissa /= 100;
+    exponent += 2;
+  }
+  while (mantissa >= 10) {
+    mantissa /= 10;
+    exponent += 1;
+  }
+  return exponent;
+}
+
+// this converts a native floating-point number to an extended-precision float.
+template <typename T>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+to_extended(T value) noexcept {
+  using equiv_uint = typename binary_format<T>::equiv_uint;
+  constexpr equiv_uint exponent_mask = binary_format<T>::exponent_mask();
+  constexpr equiv_uint mantissa_mask = binary_format<T>::mantissa_mask();
+  constexpr equiv_uint hidden_bit_mask = binary_format<T>::hidden_bit_mask();
+
+  adjusted_mantissa am;
+  int32_t bias = binary_format<T>::mantissa_explicit_bits() -
+                 binary_format<T>::minimum_exponent();
+  equiv_uint bits;
+#if FASTFLOAT_HAS_BIT_CAST
+  bits = std::bit_cast<equiv_uint>(value);
+#else
+  ::memcpy(&bits, &value, sizeof(T));
+#endif
+  if ((bits & exponent_mask) == 0) {
+    // denormal
+    am.power2 = 1 - bias;
+    am.mantissa = bits & mantissa_mask;
+  } else {
+    // normal
+    am.power2 = int32_t((bits & exponent_mask) >>
+                        binary_format<T>::mantissa_explicit_bits());
+    am.power2 -= bias;
+    am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
+  }
+
+  return am;
+}
+
+// get the extended precision value of the halfway point between b and b+u.
+// we are given a native float that represents b, so we need to adjust it
+// halfway between b and b+u.
+template <typename T>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+to_extended_halfway(T value) noexcept {
+  adjusted_mantissa am = to_extended(value);
+  am.mantissa <<= 1;
+  am.mantissa += 1;
+  am.power2 -= 1;
+  return am;
+}
+
+// round an extended-precision float to the nearest machine float.
+template <typename T, typename callback>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 void round(adjusted_mantissa &am,
+                                                         callback cb) noexcept {
+  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
+  if (-am.power2 >= mantissa_shift) {
+    // have a denormal float
+    int32_t shift = -am.power2 + 1;
+    cb(am, std::min<int32_t>(shift, 64));
+    // check for round-up: if rounding-nearest carried us to the hidden bit.
+    am.power2 = (am.mantissa <
+                 (uint64_t(1) << binary_format<T>::mantissa_explicit_bits()))
+                    ? 0
+                    : 1;
+    return;
+  }
+
+  // have a normal float, use the default shift.
+  cb(am, mantissa_shift);
+
+  // check for carry
+  if (am.mantissa >=
+      (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
+    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+    am.power2++;
+  }
+
+  // check for infinite: we could have carried to an infinite power
+  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+  if (am.power2 >= binary_format<T>::infinite_power()) {
+    am.power2 = binary_format<T>::infinite_power();
+    am.mantissa = 0;
+  }
+}
+
+template <typename callback>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 void
+round_nearest_tie_even(adjusted_mantissa &am, int32_t shift,
+                       callback cb) noexcept {
+  const uint64_t mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1;
+  const uint64_t halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1);
+  uint64_t truncated_bits = am.mantissa & mask;
+  bool is_above = truncated_bits > halfway;
+  bool is_halfway = truncated_bits == halfway;
+
+  // shift digits into position
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+
+  bool is_odd = (am.mantissa & 1) == 1;
+  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 void
+round_down(adjusted_mantissa &am, int32_t shift) noexcept {
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+}
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+skip_zeros(UC const *&first, UC const *last) noexcept {
+  uint64_t val;
+  while (!cpp20_and_in_constexpr() &&
+         std::distance(first, last) >= int_cmp_len<UC>()) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != int_cmp_zeros<UC>()) {
+      break;
+    }
+    first += int_cmp_len<UC>();
+  }
+  while (first != last) {
+    if (*first != UC('0')) {
+      break;
+    }
+    first++;
+  }
+}
+
+// determine if any non-zero digits were truncated.
+// all characters must be valid digits.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 bool
+is_truncated(UC const *first, UC const *last) noexcept {
+  // do 8-bit optimizations, can just compare to 8 literal 0s.
+  uint64_t val;
+  while (!cpp20_and_in_constexpr() &&
+         std::distance(first, last) >= int_cmp_len<UC>()) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != int_cmp_zeros<UC>()) {
+      return true;
+    }
+    first += int_cmp_len<UC>();
+  }
+  while (first != last) {
+    if (*first != UC('0')) {
+      return true;
+    }
+    ++first;
+  }
+  return false;
+}
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 bool
+is_truncated(span<const UC> s) noexcept {
+  return is_truncated(s.ptr, s.ptr + s.len());
+}
+
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+parse_eight_digits(const UC *&p, limb &value, size_t &counter,
+                   size_t &count) noexcept {
+  value = value * 100000000 + parse_eight_digits_unrolled(p);
+  p += 8;
+  counter += 8;
+  count += 8;
+}
+
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 void
+parse_one_digit(UC const *&p, limb &value, size_t &counter,
+                size_t &count) noexcept {
+  value = value * 10 + limb(*p - UC('0'));
+  p++;
+  counter++;
+  count++;
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+add_native(bigint &big, limb power, limb value) noexcept {
+  big.mul(power);
+  big.add(value);
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+round_up_bigint(bigint &big, size_t &count) noexcept {
+  // need to round-up the digits, but need to avoid rounding
+  // ....9999 to ...10000, which could cause a false halfway point.
+  add_native(big, 10, 1);
+  count++;
+}
+
+// parse the significant digits into a big integer
+template <typename UC>
+inline FASTFLOAT_CONSTEXPR20 void
+parse_mantissa(bigint &result, parsed_number_string_t<UC> &num,
+               size_t max_digits, size_t &digits) noexcept {
+  // try to minimize the number of big integer and scalar multiplication.
+  // therefore, try to parse 8 digits at a time, and multiply by the largest
+  // scalar value (9 or 19 digits) for each step.
+  size_t counter = 0;
+  digits = 0;
+  limb value = 0;
+#ifdef FASTFLOAT_64BIT_LIMB
+  size_t step = 19;
+#else
+  size_t step = 9;
+#endif
+
+  // process all integer digits.
+  UC const *p = num.integer.ptr;
+  UC const *pend = p + num.integer.len();
+  skip_zeros(p, pend);
+  // process all digits, in increments of step per loop
+  while (p != pend) {
+    while ((std::distance(p, pend) >= 8) && (step - counter >= 8) &&
+           (max_digits - digits >= 8)) {
+      parse_eight_digits(p, value, counter, digits);
+    }
+    while (counter < step && p != pend && digits < max_digits) {
+      parse_one_digit(p, value, counter, digits);
+    }
+    if (digits == max_digits) {
+      // add the temporary value, then check if we've truncated any digits
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      bool truncated = is_truncated(p, pend);
+      if (num.fraction.ptr != nullptr) {
+        truncated |= is_truncated(num.fraction);
+      }
+      if (truncated) {
+        round_up_bigint(result, digits);
+      }
+      return;
+    } else {
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      counter = 0;
+      value = 0;
+    }
+  }
+
+  // add our fraction digits, if they're available.
+  if (num.fraction.ptr != nullptr) {
+    p = num.fraction.ptr;
+    pend = p + num.fraction.len();
+    if (digits == 0) {
+      skip_zeros(p, pend);
+    }
+    // process all digits, in increments of step per loop
+    while (p != pend) {
+      while ((std::distance(p, pend) >= 8) && (step - counter >= 8) &&
+             (max_digits - digits >= 8)) {
+        parse_eight_digits(p, value, counter, digits);
+      }
+      while (counter < step && p != pend && digits < max_digits) {
+        parse_one_digit(p, value, counter, digits);
+      }
+      if (digits == max_digits) {
+        // add the temporary value, then check if we've truncated any digits
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        bool truncated = is_truncated(p, pend);
+        if (truncated) {
+          round_up_bigint(result, digits);
+        }
+        return;
+      } else {
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        counter = 0;
+        value = 0;
+      }
+    }
+  }
+
+  if (counter != 0) {
+    add_native(result, limb(powers_of_ten_uint64[counter]), value);
+  }
+}
+
+template <typename T>
+inline FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+positive_digit_comp(bigint &bigmant, int32_t exponent) noexcept {
+  FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
+  adjusted_mantissa answer;
+  bool truncated;
+  answer.mantissa = bigmant.hi64(truncated);
+  int bias = binary_format<T>::mantissa_explicit_bits() -
+             binary_format<T>::minimum_exponent();
+  answer.power2 = bigmant.bit_length() - 64 + bias;
+
+  round<T>(answer, [truncated](adjusted_mantissa &a, int32_t shift) {
+    round_nearest_tie_even(
+        a, shift,
+        [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
+          return is_above || (is_halfway && truncated) ||
+                 (is_odd && is_halfway);
+        });
+  });
+
+  return answer;
+}
+
+// the scaling here is quite simple: we have, for the real digits `m * 10^e`,
+// and for the theoretical digits `n * 2^f`. Since `e` is always negative,
+// to scale them identically, we do `n * 2^f * 5^-f`, so we now have `m * 2^e`.
+// we then need to scale by `2^(f- e)`, and then the two significant digits
+// are of the same magnitude.
+template <typename T>
+inline FASTFLOAT_CONSTEXPR20 adjusted_mantissa negative_digit_comp(
+    bigint &bigmant, adjusted_mantissa am, int32_t exponent) noexcept {
+  bigint &real_digits = bigmant;
+  int32_t real_exp = exponent;
+
+  // get the value of `b`, rounded down, and get a bigint representation of b+h
+  adjusted_mantissa am_b = am;
+  // gcc7 buf: use a lambda to remove the noexcept qualifier bug with
+  // -Wnoexcept-type.
+  round<T>(am_b,
+           [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); });
+  T b;
+  to_float(false, am_b, b);
+  adjusted_mantissa theor = to_extended_halfway(b);
+  bigint theor_digits(theor.mantissa);
+  int32_t theor_exp = theor.power2;
+
+  // scale real digits and theor digits to be same power.
+  int32_t pow2_exp = theor_exp - real_exp;
+  uint32_t pow5_exp = uint32_t(-real_exp);
+  if (pow5_exp != 0) {
+    FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
+  }
+  if (pow2_exp > 0) {
+    FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
+  } else if (pow2_exp < 0) {
+    FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
+  }
+
+  // compare digits, and use it to director rounding
+  int ord = real_digits.compare(theor_digits);
+  adjusted_mantissa answer = am;
+  round<T>(answer, [ord](adjusted_mantissa &a, int32_t shift) {
+    round_nearest_tie_even(
+        a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
+          (void)_;  // not needed, since we've done our comparison
+          (void)__; // not needed, since we've done our comparison
+          if (ord > 0) {
+            return true;
+          } else if (ord < 0) {
+            return false;
+          } else {
+            return is_odd;
+          }
+        });
+  });
+
+  return answer;
+}
+
+// parse the significant digits as a big integer to unambiguously round the
+// the significant digits. here, we are trying to determine how to round
+// an extended float representation close to `b+h`, halfway between `b`
+// (the float rounded-down) and `b+u`, the next positive float. this
+// algorithm is always correct, and uses one of two approaches. when
+// the exponent is positive relative to the significant digits (such as
+// 1234), we create a big-integer representation, get the high 64-bits,
+// determine if any lower bits are truncated, and use that to direct
+// rounding. in case of a negative exponent relative to the significant
+// digits (such as 1.2345), we create a theoretical representation of
+// `b` as a big-integer type, scaled to the same binary exponent as
+// the actual digits. we then compare the big integer representations
+// of both, and use that to direct rounding.
+template <typename T, typename UC>
+inline FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+digit_comp(parsed_number_string_t<UC> &num, adjusted_mantissa am) noexcept {
+  // remove the invalid exponent bias
+  am.power2 -= invalid_am_bias;
+
+  int32_t sci_exp = scientific_exponent(num);
+  size_t max_digits = binary_format<T>::max_digits();
+  size_t digits = 0;
+  bigint bigmant;
+  parse_mantissa(bigmant, num, max_digits, digits);
+  // can't underflow, since digits is at most max_digits.
+  int32_t exponent = sci_exp + 1 - int32_t(digits);
+  if (exponent >= 0) {
+    return positive_digit_comp<T>(bigmant, exponent);
+  } else {
+    return negative_digit_comp<T>(bigmant, am, exponent);
+  }
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_PARSE_NUMBER_H
+#define FASTFLOAT_PARSE_NUMBER_H
+
+
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <system_error>
+namespace fast_float {
+
+namespace detail {
+/**
+ * Special case +inf, -inf, nan, infinity, -infinity.
+ * The case comparisons could be made much faster given that we know that the
+ * strings a null-free and fixed.
+ **/
+template <typename T, typename UC>
+from_chars_result_t<UC> FASTFLOAT_CONSTEXPR14 parse_infnan(UC const *first,
+                                                           UC const *last,
+                                                           T &value) noexcept {
+  from_chars_result_t<UC> answer{};
+  answer.ptr = first;
+  answer.ec = std::errc(); // be optimistic
+  bool minusSign = false;
+  if (*first ==
+      UC('-')) { // assume first < last, so dereference without checks;
+                 // C++17 20.19.3.(7.1) explicitly forbids '+' here
+    minusSign = true;
+    ++first;
+  }
+#ifdef FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default
+  if (*first == UC('+')) {
+    ++first;
+  }
+#endif
+  if (last - first >= 3) {
+    if (fastfloat_strncasecmp(first, str_const_nan<UC>(), 3)) {
+      answer.ptr = (first += 3);
+      value = minusSign ? -std::numeric_limits<T>::quiet_NaN()
+                        : std::numeric_limits<T>::quiet_NaN();
+      // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7,
+      // C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan).
+      if (first != last && *first == UC('(')) {
+        for (UC const *ptr = first + 1; ptr != last; ++ptr) {
+          if (*ptr == UC(')')) {
+            answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
+            break;
+          } else if (!((UC('a') <= *ptr && *ptr <= UC('z')) ||
+                       (UC('A') <= *ptr && *ptr <= UC('Z')) ||
+                       (UC('0') <= *ptr && *ptr <= UC('9')) || *ptr == UC('_')))
+            break; // forbidden char, not nan(n-char-seq-opt)
+        }
+      }
+      return answer;
+    }
+    if (fastfloat_strncasecmp(first, str_const_inf<UC>(), 3)) {
+      if ((last - first >= 8) &&
+          fastfloat_strncasecmp(first + 3, str_const_inf<UC>() + 3, 5)) {
+        answer.ptr = first + 8;
+      } else {
+        answer.ptr = first + 3;
+      }
+      value = minusSign ? -std::numeric_limits<T>::infinity()
+                        : std::numeric_limits<T>::infinity();
+      return answer;
+    }
+  }
+  answer.ec = std::errc::invalid_argument;
+  return answer;
+}
+
+/**
+ * Returns true if the floating-pointing rounding mode is to 'nearest'.
+ * It is the default on most system. This function is meant to be inexpensive.
+ * Credit : @mwalcott3
+ */
+fastfloat_really_inline bool rounds_to_nearest() noexcept {
+  // https://lemire.me/blog/2020/06/26/gcc-not-nearest/
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return false;
+#endif
+  // See
+  // A fast function to check your floating-point rounding mode
+  // https://lemire.me/blog/2022/11/16/a-fast-function-to-check-your-floating-point-rounding-mode/
+  //
+  // This function is meant to be equivalent to :
+  // prior: #include <cfenv>
+  //  return fegetround() == FE_TONEAREST;
+  // However, it is expected to be much faster than the fegetround()
+  // function call.
+  //
+  // The volatile keywoard prevents the compiler from computing the function
+  // at compile-time.
+  // There might be other ways to prevent compile-time optimizations (e.g.,
+  // asm). The value does not need to be std::numeric_limits<float>::min(), any
+  // small value so that 1 + x should round to 1 would do (after accounting for
+  // excess precision, as in 387 instructions).
+  static volatile float fmin = std::numeric_limits<float>::min();
+  float fmini = fmin; // we copy it so that it gets loaded at most once.
+//
+// Explanation:
+// Only when fegetround() == FE_TONEAREST do we have that
+// fmin + 1.0f == 1.0f - fmin.
+//
+// FE_UPWARD:
+//  fmin + 1.0f > 1
+//  1.0f - fmin == 1
+//
+// FE_DOWNWARD or  FE_TOWARDZERO:
+//  fmin + 1.0f == 1
+//  1.0f - fmin < 1
+//
+// Note: This may fail to be accurate if fast-math has been
+// enabled, as rounding conventions may not apply.
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(push)
+//  todo: is there a VS warning?
+//  see
+//  https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013
+#elif defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wfloat-equal"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+  return (fmini + 1.0f == 1.0f - fmini);
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(pop)
+#elif defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+}
+
+} // namespace detail
+
+template <typename T> struct from_chars_caller {
+  template <typename UC>
+  FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, T &value,
+       parse_options_t<UC> options) noexcept {
+    return from_chars_advanced(first, last, value, options);
+  }
+};
+
+#if __STDCPP_FLOAT32_T__ == 1
+template <> struct from_chars_caller<std::float32_t> {
+  template <typename UC>
+  FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, std::float32_t &value,
+       parse_options_t<UC> options) noexcept {
+    // if std::float32_t is defined, and we are in C++23 mode; macro set for
+    // float32; set value to float due to equivalence between float and
+    // float32_t
+    float val;
+    auto ret = from_chars_advanced(first, last, val, options);
+    value = val;
+    return ret;
+  }
+};
+#endif
+
+#if __STDCPP_FLOAT64_T__ == 1
+template <> struct from_chars_caller<std::float64_t> {
+  template <typename UC>
+  FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, std::float64_t &value,
+       parse_options_t<UC> options) noexcept {
+    // if std::float64_t is defined, and we are in C++23 mode; macro set for
+    // float64; set value as double due to equivalence between double and
+    // float64_t
+    double val;
+    auto ret = from_chars_advanced(first, last, val, options);
+    value = val;
+    return ret;
+  }
+};
+#endif
+
+template <typename T, typename UC, typename>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value,
+           chars_format fmt /*= chars_format::general*/) noexcept {
+  return from_chars_caller<T>::call(first, last, value,
+                                    parse_options_t<UC>(fmt));
+}
+
+/**
+ * This function overload takes parsed_number_string_t structure that is created
+ * and populated either by from_chars_advanced function taking chars range and
+ * parsing options or other parsing custom function implemented by user.
+ */
+template <typename T, typename UC>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(parsed_number_string_t<UC> &pns, T &value) noexcept {
+
+  static_assert(is_supported_float_type<T>(),
+                "only some floating-point types are supported");
+  static_assert(is_supported_char_type<UC>(),
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  from_chars_result_t<UC> answer;
+
+  answer.ec = std::errc(); // be optimistic
+  answer.ptr = pns.lastmatch;
+  // The implementation of the Clinger's fast path is convoluted because
+  // we want round-to-nearest in all cases, irrespective of the rounding mode
+  // selected on the thread.
+  // We proceed optimistically, assuming that detail::rounds_to_nearest()
+  // returns true.
+  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent &&
+      pns.exponent <= binary_format<T>::max_exponent_fast_path() &&
+      !pns.too_many_digits) {
+    // Unfortunately, the conventional Clinger's fast path is only possible
+    // when the system rounds to the nearest float.
+    //
+    // We expect the next branch to almost always be selected.
+    // We could check it first (before the previous branch), but
+    // there might be performance advantages at having the check
+    // be last.
+    if (!cpp20_and_in_constexpr() && detail::rounds_to_nearest()) {
+      // We have that fegetround() == FE_TONEAREST.
+      // Next is Clinger's fast path.
+      if (pns.mantissa <= binary_format<T>::max_mantissa_fast_path()) {
+        value = T(pns.mantissa);
+        if (pns.exponent < 0) {
+          value = value / binary_format<T>::exact_power_of_ten(-pns.exponent);
+        } else {
+          value = value * binary_format<T>::exact_power_of_ten(pns.exponent);
+        }
+        if (pns.negative) {
+          value = -value;
+        }
+        return answer;
+      }
+    } else {
+      // We do not have that fegetround() == FE_TONEAREST.
+      // Next is a modified Clinger's fast path, inspired by Jakub Jelínek's
+      // proposal
+      if (pns.exponent >= 0 &&
+          pns.mantissa <=
+              binary_format<T>::max_mantissa_fast_path(pns.exponent)) {
+#if defined(__clang__) || defined(FASTFLOAT_32BIT)
+        // Clang may map 0 to -0.0 when fegetround() == FE_DOWNWARD
+        if (pns.mantissa == 0) {
+          value = pns.negative ? T(-0.) : T(0.);
+          return answer;
+        }
+#endif
+        value = T(pns.mantissa) *
+                binary_format<T>::exact_power_of_ten(pns.exponent);
+        if (pns.negative) {
+          value = -value;
+        }
+        return answer;
+      }
+    }
+  }
+  adjusted_mantissa am =
+      compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
+  if (pns.too_many_digits && am.power2 >= 0) {
+    if (am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
+      am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
+    }
+  }
+  // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa)
+  // and we have an invalid power (am.power2 < 0), then we need to go the long
+  // way around again. This is very uncommon.
+  if (am.power2 < 0) {
+    am = digit_comp<T>(pns, am);
+  }
+  to_float(pns.negative, am, value);
+  // Test for over/underflow.
+  if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) ||
+      am.power2 == binary_format<T>::infinite_power()) {
+    answer.ec = std::errc::result_out_of_range;
+  }
+  return answer;
+}
+
+template <typename T, typename UC>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(UC const *first, UC const *last, T &value,
+                    parse_options_t<UC> options) noexcept {
+
+  static_assert(is_supported_float_type<T>(),
+                "only some floating-point types are supported");
+  static_assert(is_supported_char_type<UC>(),
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  from_chars_result_t<UC> answer;
+#ifdef FASTFLOAT_SKIP_WHITE_SPACE // disabled by default
+  while ((first != last) && fast_float::is_space(uint8_t(*first))) {
+    first++;
+  }
+#endif
+  if (first == last) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+  parsed_number_string_t<UC> pns =
+      parse_number_string<UC>(first, last, options);
+  if (!pns.valid) {
+    if (options.format & chars_format::no_infnan) {
+      answer.ec = std::errc::invalid_argument;
+      answer.ptr = first;
+      return answer;
+    } else {
+      return detail::parse_infnan(first, last, value);
+    }
+  }
+
+  // call overload that takes parsed_number_string_t directly.
+  return from_chars_advanced(pns, value);
+}
+
+template <typename T, typename UC, typename>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value, int base) noexcept {
+  static_assert(is_supported_char_type<UC>(),
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  from_chars_result_t<UC> answer;
+#ifdef FASTFLOAT_SKIP_WHITE_SPACE // disabled by default
+  while ((first != last) && fast_float::is_space(uint8_t(*first))) {
+    first++;
+  }
+#endif
+  if (first == last || base < 2 || base > 36) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+  return parse_int_string(first, last, value, base);
+}
+
+} // namespace fast_float
+
+#endif
+
diff --git a/src/scratch/value.cpp b/src/scratch/value.cpp
deleted file mode 100644
index f3d8ad46..00000000
--- a/src/scratch/value.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <scratchcpp/value.h>
-#include <utf8.h>
-
-using namespace libscratchcpp;
-
-std::u16string Value::toUtf16() const
-{
-    return utf8::utf8to16(toString());
-}
diff --git a/src/scratch/value_functions.cpp b/src/scratch/value_functions.cpp
new file mode 100644
index 00000000..cfa8db4a
--- /dev/null
+++ b/src/scratch/value_functions.cpp
@@ -0,0 +1,642 @@
+#include <ctgmath>
+#include <cassert>
+#include <utf8.h>
+
+#include "value_functions_p.h"
+
+namespace libscratchcpp
+{
+
+extern "C"
+{
+    /* free */
+
+    /*! Frees memory used by the given value if it's a string. */
+    void value_free(ValueData *v)
+    {
+        if (v->type == ValueType::String) {
+            assert(v->stringValue);
+            free(v->stringValue);
+            v->stringValue = nullptr;
+            v->stringSize = 0;
+        }
+    }
+
+    /* init */
+
+    /*! Initializes the given value. */
+    void value_init(ValueData *v)
+    {
+        v->type = ValueType::Integer;
+        v->intValue = 0;
+    }
+
+    /* assign */
+
+    /*! Assigns number of type 'float' to the given value. */
+    void value_assign_float(ValueData *v, float numberValue)
+    {
+        value_free(v);
+
+        if (value_isInf(numberValue))
+            v->type = ValueType::Infinity;
+        else if (value_isNegativeInf(numberValue))
+            v->type = ValueType::NegativeInfinity;
+        else if (std::isnan(numberValue))
+            v->type = ValueType::NaN;
+        else {
+            v->type = ValueType::Double;
+            v->doubleValue = value_floatToDouble(numberValue);
+        }
+    }
+
+    /*! Assigns number of type 'double' to the given value. */
+    void value_assign_double(ValueData *v, double numberValue)
+    {
+        value_free(v);
+
+        if (value_isInf(numberValue))
+            v->type = ValueType::Infinity;
+        else if (value_isNegativeInf(numberValue))
+            v->type = ValueType::NegativeInfinity;
+        else if (std::isnan(numberValue))
+            v->type = ValueType::NaN;
+        else {
+            v->type = ValueType::Double;
+            v->doubleValue = numberValue;
+        }
+    }
+
+    /*! Assigns number of type 'int' to the given value. */
+    void value_assign_int(ValueData *v, int numberValue)
+    {
+        value_free(v);
+
+        v->type = ValueType::Integer;
+        v->intValue = numberValue;
+    }
+
+    /*! Assigns number of type 'size_t' to the given value. */
+    void value_assign_size_t(ValueData *v, size_t numberValue)
+    {
+        value_free(v);
+
+        v->type = ValueType::Integer;
+        v->intValue = numberValue;
+    }
+
+    /*! Assigns number of type 'long' to the given value. */
+    void value_assign_long(ValueData *v, long numberValue)
+    {
+        value_free(v);
+
+        v->type = ValueType::Integer;
+        v->intValue = numberValue;
+    }
+
+    /*! Assigns boolean to the given value. */
+    void value_assign_bool(ValueData *v, bool boolValue)
+    {
+        value_free(v);
+
+        v->type = ValueType::Bool;
+        v->boolValue = boolValue;
+    }
+
+    /*! Assigns string to the given value. */
+    void value_assign_string(ValueData *v, const std::string &stringValue)
+    {
+        value_assign_cstring(v, stringValue.c_str());
+    }
+
+    /*! Assigns C string to the given value. */
+    void value_assign_cstring(ValueData *v, const char *stringValue)
+    {
+        if (strcmp(stringValue, "Infinity") == 0) {
+            value_free(v);
+            v->type = ValueType::Infinity;
+        } else if (strcmp(stringValue, "-Infinity") == 0) {
+            value_free(v);
+            v->type = ValueType::NegativeInfinity;
+        } else if (strcmp(stringValue, "NaN") == 0) {
+            value_free(v);
+            v->type = ValueType::NaN;
+        } else if (v->type == ValueType::String) {
+            value_replaceStr(v, stringValue);
+        } else {
+            value_free(v);
+            value_initStr(v, stringValue);
+        }
+    }
+
+    /*! Assigns special value to the given value. */
+    void value_assign_special(ValueData *v, SpecialValue specialValue)
+    {
+        value_free(v);
+
+        if (specialValue == SpecialValue::Infinity)
+            v->type = ValueType::Infinity;
+        else if (specialValue == SpecialValue::NegativeInfinity)
+            v->type = ValueType::NegativeInfinity;
+        else if (specialValue == SpecialValue::NaN)
+            v->type = ValueType::NaN;
+        else {
+            v->type = ValueType::Integer;
+            v->intValue = 0;
+        }
+    }
+
+    /*! Assigns another value to the given value. */
+    void value_assign_copy(ValueData *v, const libscratchcpp::ValueData *another)
+    {
+        if (another->type == ValueType::Integer) {
+            value_free(v);
+            v->intValue = another->intValue;
+        } else if (another->type == ValueType::Double) {
+            value_free(v);
+            v->doubleValue = another->doubleValue;
+        } else if (another->type == ValueType::Bool) {
+            value_free(v);
+            v->boolValue = another->boolValue;
+        } else if (another->type == ValueType::String) {
+            if (v->type == ValueType::String)
+                value_replaceStr(v, another->stringValue);
+            else {
+                value_free(v);
+                value_initStr(v, another->stringValue);
+            }
+        }
+
+        v->type = another->type;
+    }
+
+    /* type checkers */
+
+    /*! Returns true if the given value is Infinity. */
+    bool value_isInfinity(const libscratchcpp::ValueData *v)
+    {
+        switch (v->type) {
+            case ValueType::Infinity:
+                return true;
+            case ValueType::Integer:
+                return value_isInf(v->intValue);
+            case ValueType::Double:
+                return value_isInf(v->doubleValue);
+            case ValueType::String:
+                return strcmp(v->stringValue, "Infinity") == 0;
+            default:
+                return false;
+        }
+    }
+
+    /*! Returns true if the given value is -Infinity. */
+    bool value_isNegativeInfinity(const libscratchcpp::ValueData *v)
+    {
+        switch (v->type) {
+            case ValueType::NegativeInfinity:
+                return true;
+            case ValueType::Integer:
+                return value_isNegativeInf(-v->intValue);
+            case ValueType::Double:
+                return value_isNegativeInf(-v->doubleValue);
+            case ValueType::String:
+                return strcmp(v->stringValue, "-Infinity") == 0;
+            default:
+                return false;
+        }
+    }
+
+    /*! Returns true if the given value is NaN. */
+    bool value_isNaN(const libscratchcpp::ValueData *v)
+    {
+        switch (v->type) {
+            case ValueType::NaN:
+                return true;
+            case ValueType::Double:
+                assert(!std::isnan(v->doubleValue));
+                return std::isnan(v->doubleValue);
+            case ValueType::String:
+                return strcmp(v->stringValue, "NaN") == 0;
+            default:
+                return false;
+        }
+    }
+
+    /*! Returns true if the given value is a number. */
+    bool value_isNumber(const libscratchcpp::ValueData *v)
+    {
+        return v->type == ValueType::Integer || v->type == ValueType::Double;
+    }
+
+    /*! Returns true if the given value is a number or can be converted to a number. */
+    bool value_isValidNumber(const libscratchcpp::ValueData *v)
+    {
+        if (value_isNaN(v))
+            return false;
+
+        if (value_isInfinity(v) || value_isNegativeInfinity(v))
+            return true;
+
+        assert(v->type != ValueType::Infinity && v->type != ValueType::NegativeInfinity);
+
+        switch (v->type) {
+            case ValueType::Integer:
+            case ValueType::Double:
+            case ValueType::Bool:
+                return true;
+            case ValueType::String:
+                return strlen(v->stringValue) == 0 || value_checkString(v->stringValue) > 0;
+            default:
+                return false;
+        }
+    }
+
+    /*! Returns true if the given value represents a round integer. */
+    bool value_isInt(const ValueData *v)
+    {
+        // https://github.com/scratchfoundation/scratch-vm/blob/112989da0e7306eeb405a5c52616e41c2164af24/src/util/cast.js#L157-L181
+        switch (v->type) {
+            case ValueType::Integer:
+            case ValueType::Bool:
+            case ValueType::Infinity:
+            case ValueType::NegativeInfinity:
+            case ValueType::NaN:
+                return true;
+            case ValueType::Double: {
+                double intpart;
+                std::modf(v->doubleValue, &intpart);
+                return v->doubleValue == intpart;
+            }
+            case ValueType::String:
+                return value_checkString(v->stringValue) == 1;
+        }
+
+        return false;
+    }
+
+    /*! Returns true if the given value is a boolean. */
+    bool value_isBool(const libscratchcpp::ValueData *v)
+    {
+        return v->type == ValueType::Bool;
+    }
+
+    /*! Returns true if the given value is a string. */
+    bool value_isString(const libscratchcpp::ValueData *v)
+    {
+        return v->type == ValueType::String;
+    }
+
+    /* conversion */
+
+    /*! Returns the long representation of the given value. */
+    long value_toLong(const libscratchcpp::ValueData *v)
+    {
+        if (v->type == ValueType::Integer)
+            return v->intValue;
+        else if (v->type == ValueType::Double)
+            return v->doubleValue;
+        else if (v->type == ValueType::Bool)
+            return v->boolValue;
+        else if (v->type == ValueType::String)
+            return value_stringToLong(v->stringValue);
+        else
+            return 0;
+    }
+
+    /*! Returns the int representation of the given value. */
+    int value_toInt(const libscratchcpp::ValueData *v)
+    {
+        if (v->type == ValueType::Integer)
+            return v->intValue;
+        else if (v->type == ValueType::Double)
+            return v->doubleValue;
+        else if (v->type == ValueType::Bool)
+            return v->boolValue;
+        else if (v->type == ValueType::String)
+            return value_stringToLong(v->stringValue);
+        else
+            return 0;
+    }
+
+    /*! Returns the double representation of the given value. */
+    double value_toDouble(const libscratchcpp::ValueData *v)
+    {
+        if (v->type == ValueType::Double)
+            return v->doubleValue;
+        else if (v->type == ValueType::Integer)
+            return v->intValue;
+        else if (v->type == ValueType::Bool)
+            return v->boolValue;
+        else if (v->type == ValueType::String)
+            return value_stringToDouble(v->stringValue);
+        else if (v->type == ValueType::Infinity)
+            return std::numeric_limits<double>::infinity();
+        else if (v->type == ValueType::NegativeInfinity)
+            return -std::numeric_limits<double>::infinity();
+        else
+            return 0;
+    }
+
+    /*! Returns the boolean representation of the given value. */
+    bool value_toBool(const libscratchcpp::ValueData *v)
+    {
+        if (v->type == ValueType::Bool) {
+            return v->boolValue;
+        } else if (v->type == ValueType::Integer) {
+            return v->intValue != 0;
+        } else if (v->type == ValueType::Double) {
+            return v->doubleValue != 0;
+        } else if (v->type == ValueType::String) {
+            return strlen(v->stringValue) != 0 && !value_stringsEqual(v->stringValue, "false") && strcmp(v->stringValue, "0") != 0;
+        } else if (v->type == ValueType::Infinity || v->type == ValueType::NegativeInfinity) {
+            return true;
+        } else if (v->type == ValueType::NaN) {
+            return false;
+        } else {
+            return false;
+        }
+    }
+
+    /*! Writes the string representation of the given value to dst. */
+    void value_toString(const libscratchcpp::ValueData *v, std::string *dst)
+    {
+        if (v->type == ValueType::String)
+            dst->assign(v->stringValue);
+        else if (v->type == ValueType::Integer)
+            dst->assign(std::to_string(v->intValue));
+        else if (v->type == ValueType::Double)
+            dst->assign(value_doubleToString(v->doubleValue));
+        else if (v->type == ValueType::Bool)
+            dst->assign(v->boolValue ? "true" : "false");
+        else if (v->type == ValueType::Infinity)
+            dst->assign("Infinity");
+        else if (v->type == ValueType::NegativeInfinity)
+            dst->assign("-Infinity");
+        else if (v->type == ValueType::NaN)
+            dst->assign("NaN");
+        else
+            dst->clear();
+    }
+
+    /*! Writes the UTF-16 representation of the given value to dst. */
+    void value_toUtf16(const libscratchcpp::ValueData *v, std::u16string *dst)
+    {
+        std::string s;
+        value_toString(v, &s);
+        dst->assign(utf8::utf8to16(s));
+    }
+
+    /* operations */
+
+    /*! Adds the given values and writes the result to dst. */
+    void value_add(const libscratchcpp::ValueData *v1, const libscratchcpp::ValueData *v2, ValueData *dst)
+    {
+        if (v1->type == ValueType::Integer && v2->type == ValueType::Integer) {
+            value_assign_long(dst, v1->intValue + v2->intValue);
+            return;
+        } else if (v1->type == ValueType::Double && v2->type == ValueType::Double) {
+            value_assign_double(dst, v1->doubleValue + v2->doubleValue);
+            return;
+        } else if (v1->type == ValueType::Bool && v2->type == ValueType::Bool) {
+            value_assign_long(dst, v1->boolValue + v2->boolValue);
+            return;
+        } else if ((static_cast<int>(v1->type) < 0) || (static_cast<int>(v2->type) < 0)) {
+            if ((v1->type == ValueType::Infinity && v2->type == ValueType::NegativeInfinity) || (v1->type == ValueType::NegativeInfinity && v2->type == ValueType::Infinity)) {
+                value_assign_special(dst, SpecialValue::NaN);
+                return;
+            } else if (v1->type == ValueType::Infinity || v2->type == ValueType::Infinity) {
+                value_assign_special(dst, SpecialValue::Infinity);
+                return;
+            } else if (v1->type == ValueType::NegativeInfinity || v2->type == ValueType::NegativeInfinity) {
+                value_assign_special(dst, SpecialValue::NegativeInfinity);
+                return;
+            }
+        }
+
+        value_assign_double(dst, value_toDouble(v1) + value_toDouble(v2));
+    }
+
+    /*! Subtracts the given values and writes the result to dst. */
+    void value_subtract(const libscratchcpp::ValueData *v1, const libscratchcpp::ValueData *v2, ValueData *dst)
+    {
+        if (v1->type == ValueType::Integer && v2->type == ValueType::Integer) {
+            value_assign_long(dst, v1->intValue - v2->intValue);
+            return;
+        } else if (v1->type == ValueType::Double && v2->type == ValueType::Double) {
+            value_assign_double(dst, v1->doubleValue - v2->doubleValue);
+            return;
+        } else if (v1->type == ValueType::Bool && v2->type == ValueType::Bool) {
+            value_assign_long(dst, v1->boolValue - v2->boolValue);
+            return;
+        } else if ((static_cast<int>(v1->type) < 0) || (static_cast<int>(v2->type) < 0)) {
+            if ((v1->type == ValueType::Infinity && v2->type == ValueType::Infinity) || (v1->type == ValueType::NegativeInfinity && v2->type == ValueType::NegativeInfinity)) {
+                value_assign_special(dst, SpecialValue::NaN);
+                return;
+            } else if (v1->type == ValueType::Infinity || v2->type == ValueType::NegativeInfinity) {
+                value_assign_special(dst, SpecialValue::Infinity);
+                return;
+            } else if (v1->type == ValueType::NegativeInfinity || v2->type == ValueType::Infinity) {
+                value_assign_special(dst, SpecialValue::NegativeInfinity);
+                return;
+            }
+        }
+
+        value_assign_double(dst, value_toDouble(v1) - value_toDouble(v2));
+    }
+
+    /*! Multiplies the given values and writes the result to dst. */
+    void value_multiply(const libscratchcpp::ValueData *v1, const libscratchcpp::ValueData *v2, ValueData *dst)
+    {
+        if (v1->type == ValueType::Integer && v2->type == ValueType::Integer)
+            value_assign_long(dst, v1->intValue * v2->intValue);
+        else if (v1->type == ValueType::Double && v2->type == ValueType::Double)
+            value_assign_double(dst, v1->doubleValue * v2->doubleValue);
+        else if (v1->type == ValueType::Bool && v2->type == ValueType::Bool)
+            value_assign_long(dst, v1->boolValue * v2->boolValue);
+        else {
+            const ValueType t1 = v1->type, t2 = v2->type;
+
+            if ((static_cast<int>(t1) < 0 && t1 != ValueType::NaN) || (static_cast<int>(t2) < 0 && t2 != ValueType::NaN)) {
+                if (t1 == ValueType::Infinity || t1 == ValueType::NegativeInfinity || t2 == ValueType::Infinity || t2 == ValueType::NegativeInfinity) {
+                    bool mode = (t1 == ValueType::Infinity || t2 == ValueType::Infinity);
+                    const ValueData *value;
+
+                    if ((t1 == ValueType::Infinity && (t2 == ValueType::Infinity || t2 == ValueType::NegativeInfinity)) || (t2 != ValueType::Infinity && t2 != ValueType::NegativeInfinity))
+                        value = v2;
+                    else
+                        value = v1;
+
+                    if (value_isPositive(value))
+                        value_assign_special(dst, mode ? SpecialValue::Infinity : SpecialValue::NegativeInfinity);
+                    else if (value_isNegative(value))
+                        value_assign_special(dst, mode ? SpecialValue::NegativeInfinity : SpecialValue::Infinity);
+                    else
+                        value_assign_special(dst, SpecialValue::NaN);
+                }
+            } else
+                value_assign_double(dst, value_toDouble(v1) * value_toDouble(v2));
+        }
+    }
+
+    /*! Divides the given values and writes the result to dst. */
+    void value_divide(const libscratchcpp::ValueData *v1, const libscratchcpp::ValueData *v2, ValueData *dst)
+    {
+        if (value_isZero(v1) && value_isZero(v2))
+            value_assign_special(dst, SpecialValue::NaN);
+        else if (value_toDouble(v2) == 0) {
+            if (value_isPositive(v1))
+                value_assign_special(dst, SpecialValue::Infinity);
+            else
+                value_assign_special(dst, SpecialValue::NegativeInfinity);
+        } else if ((v1->type == ValueType::Infinity || v1->type == ValueType::NegativeInfinity) && (v2->type == ValueType::Infinity || v2->type == ValueType::NegativeInfinity)) {
+            value_assign_special(dst, SpecialValue::NaN);
+        } else if (v1->type == ValueType::Infinity || v1->type == ValueType::NegativeInfinity) {
+            if (value_toDouble(v2) < 0) {
+                if (v1->type == ValueType::Infinity)
+                    value_assign_special(dst, SpecialValue::NegativeInfinity);
+                else
+                    value_assign_special(dst, SpecialValue::Infinity);
+            } else {
+                if (v1->type == ValueType::Infinity)
+                    value_assign_special(dst, SpecialValue::Infinity);
+                else
+                    value_assign_special(dst, SpecialValue::NegativeInfinity);
+            }
+        } else if (v2->type == ValueType::Infinity || v2->type == ValueType::NegativeInfinity) {
+            value_assign_long(dst, 0);
+        } else
+            value_assign_double(dst, value_toDouble(v1) / value_toDouble(v2));
+    }
+
+    /*! Calculates the modulo the given values and writes the result to dst. */
+    void value_mod(const libscratchcpp::ValueData *v1, const libscratchcpp::ValueData *v2, ValueData *dst)
+    {
+        if ((v2 == 0) || (v1->type == ValueType::Infinity || v1->type == ValueType::NegativeInfinity))
+            value_assign_special(dst, SpecialValue::NaN);
+        else if (v2->type == ValueType::Infinity || v2->type == ValueType::NegativeInfinity)
+            value_assign_double(dst, value_toDouble(v1));
+        else if (value_isNegative(v1) || value_isNegative(v2))
+            value_assign_double(dst, fmod(value_toDouble(v2) + fmod(value_toDouble(v1), -value_toDouble(v2)), value_toDouble(v2)));
+        else
+            value_assign_double(dst, fmod(value_toDouble(v1), value_toDouble(v2)));
+    }
+
+    /* comparison */
+
+    /*! Returns true if the given values are equal. */
+    bool value_equals(const libscratchcpp::ValueData *v1, const libscratchcpp::ValueData *v2)
+    {
+        // https://github.com/scratchfoundation/scratch-vm/blob/112989da0e7306eeb405a5c52616e41c2164af24/src/util/cast.js#L121-L150
+        assert(v1 && v2);
+
+        if (v1->type == ValueType::Integer && v2->type == ValueType::Integer)
+            return v1->intValue == v2->intValue;
+        else if (v1->type == ValueType::Double && v2->type == ValueType::Double)
+            return v1->doubleValue == v2->doubleValue;
+        else if (v1->type == ValueType::Bool && v2->type == ValueType::Bool)
+            return v1->boolValue == v2->boolValue;
+
+        bool ok;
+        double n1 = value_getNumber(v1, &ok);
+        double n2;
+
+        if (ok)
+            n2 = value_getNumber(v2, &ok);
+
+        if (!ok) {
+            // At least one argument can't be converted to a number
+            // Scratch compares strings as case insensitive
+            std::u16string s1, s2;
+            value_toUtf16(v1, &s1);
+            value_toUtf16(v2, &s2);
+            return value_u16StringsEqual(s1, s2);
+        }
+
+        // Handle the special case of Infinity
+        if ((static_cast<int>(v1->type) < 0) && (static_cast<int>(v2->type) < 0)) {
+            assert(v1->type != ValueType::NaN);
+            assert(v2->type != ValueType::NaN);
+            return v1->type == v2->type;
+        }
+
+        // Compare as numbers
+        return n1 == n2;
+    }
+
+    /*! Returns true if the first value is greater than the second value. */
+    bool value_greater(const libscratchcpp::ValueData *v1, const libscratchcpp::ValueData *v2)
+    {
+        assert(v1 && v2);
+
+        if (v1->type == ValueType::Integer && v2->type == ValueType::Integer)
+            return v1->intValue > v2->intValue;
+        else if (v1->type == ValueType::Double && v2->type == ValueType::Double)
+            return v1->doubleValue > v2->doubleValue;
+        else if (v1->type == ValueType::Bool && v2->type == ValueType::Bool)
+            return v1->boolValue > v2->boolValue;
+        else if ((static_cast<int>(v1->type) < 0) || (static_cast<int>(v2->type) < 0)) {
+            if (v1->type == ValueType::Infinity) {
+                return v2->type != ValueType::Infinity;
+            } else if (v1->type == ValueType::NegativeInfinity)
+                return false;
+            else if (v2->type == ValueType::Infinity)
+                return false;
+            else if (v2->type == ValueType::NegativeInfinity)
+                return true;
+        }
+
+        double n1, n2;
+
+        if (v1->type == ValueType::String)
+            n1 = value_stringToDouble(v1->stringValue);
+        else
+            n1 = value_toDouble(v1);
+
+        if (v2->type == ValueType::String)
+            n2 = value_stringToDouble(v2->stringValue);
+        else
+            n2 = value_toDouble(v2);
+
+        return n1 > n2;
+    }
+
+    /*! Returns true if the first value is lower than the second value. */
+    bool value_lower(const libscratchcpp::ValueData *v1, const libscratchcpp::ValueData *v2)
+    {
+        assert(v1 && v2);
+
+        if (v1->type == ValueType::Integer && v2->type == ValueType::Integer)
+            return v1->intValue < v2->intValue;
+        else if (v1->type == ValueType::Double && v2->type == ValueType::Double)
+            return v1->doubleValue < v2->doubleValue;
+        else if (v1->type == ValueType::Bool && v2->type == ValueType::Bool)
+            return v1->boolValue < v2->boolValue;
+        else if ((static_cast<int>(v1->type) < 0) || (static_cast<int>(v2->type) < 0)) {
+            if (v1->type == ValueType::Infinity) {
+                return false;
+            } else if (v1->type == ValueType::NegativeInfinity)
+                return v2->type != ValueType::NegativeInfinity;
+            else if (v2->type == ValueType::Infinity)
+                return v1->type != ValueType::Infinity;
+            else if (v2->type == ValueType::NegativeInfinity)
+                return false;
+        }
+
+        return value_toDouble(v1) < value_toDouble(v2);
+        double n1, n2;
+
+        if (v1->type == ValueType::String)
+            n1 = value_stringToDouble(v1->stringValue);
+        else
+            n1 = value_toDouble(v1);
+
+        if (v2->type == ValueType::String)
+            n2 = value_stringToDouble(v2->stringValue);
+        else
+            n2 = value_toDouble(v2);
+
+        return n1 < n2;
+    }
+}
+
+} // namespace libscratchcpp
diff --git a/src/scratch/value_functions_p.h b/src/scratch/value_functions_p.h
new file mode 100644
index 00000000..3ccd447d
--- /dev/null
+++ b/src/scratch/value_functions_p.h
@@ -0,0 +1,558 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/value_functions.h>
+#include <algorithm>
+#include <limits>
+#include <ctgmath>
+#include <iomanip>
+#include <charconv>
+#include <cassert>
+
+#include "thirdparty/fast_float/fast_float.h"
+
+// Faster than std::isspace()
+#define IS_SPACE(x) (x == ' ' || x == '\f' || x == '\n' || x == '\r' || x == '\t' || x == '\v')
+
+namespace libscratchcpp
+{
+
+template<typename T>
+inline unsigned int value_digitCount(T v)
+{
+    const T epsilon = 0.0000001;
+    T intpart;
+    unsigned int i = 1, j = 0;
+
+    if (std::abs(std::modf(v, &intpart)) >= epsilon) {
+        T tmp_intpart;
+
+        while (std::abs(std::modf(v * std::pow(10, i), &tmp_intpart)) >= epsilon)
+            i++;
+    }
+
+    while (std::abs(intpart / pow(10, j)) >= 1.0)
+        j++;
+
+    return i + j;
+}
+
+template<typename T>
+inline bool value_isInf(T v)
+{
+    return v > 0 && std::isinf(v);
+}
+
+template<typename T>
+inline bool value_isNegativeInf(T v)
+{
+    return v < 0 && std::isinf(v);
+}
+
+extern "C"
+{
+
+    inline long value_convert_int_str(const char *str, int n, bool *ok)
+    {
+        if (ok)
+            *ok = false;
+
+        const char *begin = str;
+        const char *end = begin + n;
+
+        bool isNegative = false;
+        long ret = 0;
+
+        if (*str == '-' || *str == '+') {
+            isNegative = (*str == '-');
+            ++str;
+
+            if (str == begin + n)
+                return 0;
+        }
+
+        while (str < end) {
+            if (*str < '0' || *str > '9')
+                return 0;
+
+            ret = ret * 10 + (*str++ - '0');
+        }
+
+        if (ok)
+            *ok = true;
+
+        if (isNegative)
+            return -ret;
+        else
+            return ret;
+    }
+
+    inline size_t value_getSize(size_t x)
+    {
+        if (x == 0)
+            return 0;
+
+        size_t ret = 1;
+
+        while (ret < x)
+            ret *= 2;
+
+        return ret;
+    }
+
+    inline void value_initStr(ValueData *v, const char *s)
+    {
+        const size_t len = strlen(s);
+        v->stringSize = value_getSize(len + 1);
+        v->type = ValueType::String;
+        v->stringValue = (char *)malloc((v->stringSize * sizeof(char)));
+        memcpy(v->stringValue, s, len);
+        v->stringValue[len] = '\0';
+    }
+
+    inline void value_replaceStr(ValueData *v, const char *s)
+    {
+        const size_t len = strlen(s);
+        const size_t size = value_getSize(len + 1);
+
+        if (size == 0)
+            return;
+
+        if (size > v->stringSize || v->stringSize / size > 3) {
+            v->stringSize = size;
+            v->stringValue = (char *)realloc(v->stringValue, v->stringSize * sizeof(char));
+        }
+
+        memcpy(v->stringValue, s, len);
+        v->stringValue[len] = '\0';
+    }
+
+    inline bool value_u16StringsEqual(std::u16string s1, std::u16string s2)
+    {
+        std::transform(s1.begin(), s1.end(), s1.begin(), ::tolower);
+        std::transform(s2.begin(), s2.end(), s2.begin(), ::tolower);
+        return (s1.compare(s2) == 0);
+    }
+
+    inline bool value_stringsEqual(const char *s1, const char *s2)
+    {
+        std::string str1(s1);
+        std::string str2(s2);
+        std::transform(str1.begin(), str1.end(), str1.begin(), ::tolower);
+        std::transform(str2.begin(), str2.end(), str2.begin(), ::tolower);
+        return (str1.compare(str2) == 0);
+    }
+
+    inline long value_hexToDec(const char *s, int n, bool *ok)
+    {
+        if (ok)
+            *ok = false;
+
+        // Ignore dots, plus and minus signs
+        const char *p = s;
+
+        while (p < s + n) {
+            if (*p == '.' || *p == '+' || *p == '-')
+                return 0;
+
+            p++;
+        }
+
+        long result = 0;
+        auto [ptr, ec] = std::from_chars(s, s + n, result, 16);
+
+        if (ec == std::errc{} && ptr == s + n) {
+            if (ok)
+                *ok = true;
+
+            return result;
+        } else
+            return 0;
+    }
+
+    inline long value_octToDec(const char *s, int n, bool *ok)
+    {
+        if (ok)
+            *ok = false;
+
+        // Ignore plus and minus signs
+        const char *p = s;
+
+        while (p < s + n) {
+            if (*p == '+' || *p == '-')
+                return 0;
+
+            p++;
+        }
+
+        char *err;
+        const double ret = std::strtol(s, &err, 8);
+
+        if (*err != 0 && !std::isspace(*err))
+            return 0;
+        else {
+            if (ok)
+                *ok = true;
+
+            return ret;
+        }
+    }
+
+    inline double value_binToDec(const char *s, int n, bool *ok)
+    {
+        if (ok)
+            *ok = false;
+
+        // Ignore plus and minus signs
+        const char *p = s;
+
+        while (p < s + n) {
+            if (*p == '+' || *p == '-')
+                return 0;
+
+            p++;
+        }
+
+        char *err;
+        const double ret = std::strtol(s, &err, 2);
+
+        if (*err != 0 && !std::isspace(*err))
+            return 0;
+        else {
+            if (ok)
+                *ok = true;
+
+            return ret;
+        }
+    }
+
+    inline double value_stringToDouble(const char *s, bool *ok = nullptr)
+    {
+        if (ok)
+            *ok = false;
+
+        if (!s || *s == '\0')
+            return 0;
+
+        const size_t len = strlen(s);
+        const char *begin = s;
+        const char *end = s + len;
+
+        // Trim leading spaces
+        while (begin < end && IS_SPACE(*begin))
+            ++begin;
+
+        // Trim trailing spaces
+        while (end > begin && IS_SPACE(*(end - 1)))
+            --end;
+
+        if (begin == end) // All spaces case
+            return 0;
+
+        // Try to convert integer early
+        bool isInt = false;
+        double ret = value_convert_int_str(begin, end - begin, &isInt);
+
+        if (isInt) {
+            if (ok)
+                *ok = true;
+
+            return ret;
+        }
+
+        char *copy = nullptr;
+
+        // If there's a leading plus sign, copy the string and replace the plus sign with zero (e. g. '+.15' -> '0.15')
+        // If there's a leading minus sign with a dot, insert zero next to the minus sign (e. g. '-.15' -> '-0.15')
+        if (begin[0] == '+' || (begin[0] == '-' && end - begin > 1 && begin[1] == '.')) {
+            copy = new char[end - begin + 2];
+
+            if (begin[0] == '-') {
+                copy[0] = '-';
+                copy[1] = '0';
+                memcpy(copy + 2, begin + 1, end - begin - 1);
+                copy[end - begin + 1] = '\0';
+                end = copy + (end - begin) + 1;
+            } else {
+                memcpy(copy, begin, end - begin);
+                copy[0] = '0';
+                copy[end - begin] = '\0';
+                end = copy + (end - begin);
+            }
+            begin = copy;
+        } else {
+            // If there's a leading dot, copy the string and insert zero prior to the dot (e. g. '.15' -> '0.15')
+            if (begin[0] == '.') {
+                copy = new char[end - begin + 2];
+                copy[0] = '0';
+                memcpy(copy + 1, begin, end - begin);
+                end = copy + (end - begin) + 1;
+                begin = copy;
+            }
+        }
+
+        if (end - begin <= 0) {
+            if (copy)
+                delete[] copy;
+
+            return 0;
+        }
+
+        // Handle hex, oct and bin (currently ignored if the string was manipulated above)
+        if (!copy && end - begin > 2 && begin[0] == '0') {
+            const char prefix = begin[1];
+            const char *sub = begin + 2;
+
+            if (prefix == 'x' || prefix == 'X') {
+                return value_hexToDec(sub, end - begin - 2, ok);
+            } else if (prefix == 'o' || prefix == 'O') {
+                return value_octToDec(sub, end - begin - 2, ok);
+            } else if (prefix == 'b' || prefix == 'B') {
+                return value_binToDec(sub, end - begin - 2, ok);
+            }
+        }
+
+        // If there's a trailing dot, copy the string and append zero next to it (e. g. '1.' -> '1.0')
+        if (end[-1] == '.') {
+            if (copy) {
+                char *tmpCopy = new char[end - begin + 2];
+                memcpy(tmpCopy, begin, end - begin);
+                delete[] copy;
+                copy = tmpCopy;
+                end = copy + (end - begin) + 1;
+                begin = copy;
+            } else {
+                copy = new char[end - begin + 2];
+                memcpy(copy, begin, end - begin);
+                end = copy + (end - begin) + 1;
+                begin = copy;
+            }
+
+            copy[end - begin - 1] = '0';
+            copy[end - begin] = '\0';
+        }
+
+        // Trim leading zeros
+        bool trimmed = false;
+
+        while (begin < end && (*begin == '0') && !(begin + 1 < end && begin[1] == '.')) {
+            trimmed = true;
+            ++begin;
+        }
+
+        if (end - begin <= 0) {
+            if (ok)
+                *ok = true;
+
+            if (copy)
+                delete[] copy;
+
+            return 0;
+        }
+
+        // Ignore cases like '0+5' or '0-5'
+        if (trimmed && (begin[0] == '+' || begin[0] == '-')) {
+            if (copy)
+                delete[] copy;
+
+            return 0;
+        }
+
+        auto [ptr, ec] = fast_float::from_chars(begin, end, ret, fast_float::chars_format::json);
+
+        if (copy)
+            delete[] copy;
+
+        if (ec == std::errc{} && ptr == end) {
+            if (ok)
+                *ok = true;
+
+            return ret;
+        } else
+            return 0;
+
+        // Special values
+        if (strncmp(s, "Infinity", len) == 0) {
+            if (ok)
+                *ok = true;
+            return std::numeric_limits<double>::infinity();
+        } else if (strncmp(s, "-Infinity", len) == 0) {
+            if (ok)
+                *ok = true;
+            return -std::numeric_limits<double>::infinity();
+        } else if (strncmp(s, "NaN", len) == 0) {
+            if (ok)
+                *ok = true;
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+
+        return 0;
+    }
+
+    inline long value_stringToLong(const char *s, bool *ok = nullptr)
+    {
+        return value_stringToDouble(s, ok);
+    }
+
+    inline bool value_stringIsInt(const char *s, int n)
+    {
+        const char *p = s;
+
+        while (p < s + n) {
+            if (*p == '.' || *p == 'e' || *p == 'E')
+                return false;
+
+            p++;
+        }
+
+        return true;
+    }
+}
+
+inline std::string value_doubleToString(double v)
+{
+    std::stringstream stream;
+
+    if (v != 0) {
+        const int exponent = std::log10(std::abs(v));
+
+        if (exponent > 20)
+            stream << std::scientific << std::setprecision(value_digitCount(v / std::pow(10, exponent + 1)) - 1) << v;
+        else
+            stream << std::setprecision(std::max(16u, value_digitCount(v))) << v;
+    } else
+        stream << std::setprecision(std::max(16u, value_digitCount(v))) << v;
+
+    std::string s = stream.str();
+    std::size_t index;
+
+    for (int i = 0; i < 2; i++) {
+        if (i == 0)
+            index = s.find("e+");
+        else
+            index = s.find("e-");
+
+        if (index != std::string::npos) {
+            while ((s.size() >= index + 3) && (s[index + 2] == '0'))
+                s.erase(index + 2, 1);
+        }
+    }
+
+    return s;
+}
+
+extern "C"
+{
+    inline double value_floatToDouble(float v)
+    {
+        unsigned int digits = value_digitCount(v);
+        double f = std::pow(10, digits);
+        return std::round(v * f) / f;
+    }
+
+    inline int value_checkString(const char *str)
+    {
+        bool ok;
+
+        if (value_stringIsInt(str, strlen(str))) {
+            value_stringToLong(str, &ok);
+            return ok ? 1 : 0;
+        } else {
+            value_stringToDouble(str, &ok);
+            return ok ? 2 : 0;
+        }
+    }
+
+    inline double value_getNumber(const ValueData *v, bool *ok = nullptr)
+    {
+        // Equivalent to JavaScript Number(), *ok == false means NaN
+        if (ok)
+            *ok = true;
+
+        // Since functions calling this already prioritize int, double and bool,
+        // we can optimize by prioritizing the other types here.
+        if (v->type == ValueType::String)
+            return value_stringToDouble(v->stringValue, ok);
+        else if (v->type == ValueType::Infinity)
+            return std::numeric_limits<double>::infinity();
+        else if (v->type == ValueType::NegativeInfinity)
+            return -std::numeric_limits<double>::infinity();
+        else if (v->type == ValueType::NaN) {
+            if (ok)
+                *ok = false;
+
+            return 0;
+        } else if (v->type == ValueType::Integer)
+            return v->intValue;
+        else if (v->type == ValueType::Double)
+            return v->doubleValue;
+        else if (v->type == ValueType::Bool)
+            return v->boolValue;
+        else {
+            assert(false); // this should never happen
+            if (ok)
+                *ok = false;
+
+            return 0;
+        }
+    }
+
+    bool value_isPositive(const ValueData *v)
+    {
+        if (v->type == ValueType::Integer)
+            return v->intValue > 0;
+        else if (v->type == ValueType::Double)
+            return v->doubleValue > 0;
+        else if (v->type == ValueType::Bool)
+            return v->boolValue;
+        else if (static_cast<int>(v->type) < 0) {
+            if (v->type == ValueType::Infinity)
+                return true;
+            else
+                return false;
+        }
+
+        return value_toDouble(v) > 0;
+    }
+
+    bool value_isNegative(const ValueData *v)
+    {
+        if (v->type == ValueType::Integer)
+            return v->intValue < 0;
+        else if (v->type == ValueType::Double)
+            return v->doubleValue < 0;
+        else if (v->type == ValueType::Bool)
+            return false;
+        else if (static_cast<int>(v->type) < 0) {
+            if (v->type == ValueType::NegativeInfinity)
+                return true;
+            else
+                return false;
+        }
+
+        return value_toDouble(v) < 0;
+    }
+
+    bool value_isZero(const ValueData *v)
+    {
+        if (v->type == ValueType::Integer)
+            return v->intValue == 0;
+        else if (v->type == ValueType::Double)
+            return v->doubleValue == 0;
+        else if (v->type == ValueType::Bool)
+            return !v->boolValue;
+        else if (static_cast<int>(v->type) < 0)
+            return false;
+
+        bool ok;
+        double n = value_getNumber(v, &ok);
+
+        if (ok)
+            return n == 0;
+        else
+            return false;
+    }
+}
+
+} // namespace libscratchcpp
diff --git a/src/scratchconfiguration.cpp b/src/scratchconfiguration.cpp
index 24411dec..96ea1468 100644
--- a/src/scratchconfiguration.cpp
+++ b/src/scratchconfiguration.cpp
@@ -5,22 +5,25 @@
 #include <iostream>
 
 #include "scratchconfiguration_p.h"
-#include "blocks/standardblocks.h"
 
 using namespace libscratchcpp;
 
-std::unique_ptr<ScratchConfigurationPrivate> ScratchConfiguration::impl = std::make_unique<ScratchConfigurationPrivate>();
-
 /*! Registers the given extension. */
 void ScratchConfiguration::registerExtension(std::shared_ptr<IExtension> extension)
 {
-    impl->registerExtension(extension);
+    getImpl()->registerExtension(extension);
+}
+
+/*! Unregisters the given extension. */
+void ScratchConfiguration::removeExtension(std::shared_ptr<IExtension> extension)
+{
+    getImpl()->removeExtension(extension);
 }
 
 /*! Returns the extension with the given name, or nullptr if it isn't registered. */
 IExtension *ScratchConfiguration::getExtension(const std::string &name)
 {
-    return impl->getExtension(name);
+    return getImpl()->getExtension(name);
 }
 
 /*! Registers the given graphics effect. */
@@ -29,21 +32,21 @@ void ScratchConfiguration::registerGraphicsEffect(std::shared_ptr<IGraphicsEffec
     if (!effect)
         return;
 
-    impl->graphicsEffects[effect->name()] = effect;
+    getImpl()->graphicsEffects[effect->name()] = effect;
 }
 
 /*! Removes the given graphics effect. */
 void ScratchConfiguration::removeGraphicsEffect(const std::string &name)
 {
-    impl->graphicsEffects.erase(name);
+    getImpl()->graphicsEffects.erase(name);
 }
 
 /*! Returns the graphics effect with the given name, or nullptr if it isn't registered. */
 IGraphicsEffect *ScratchConfiguration::getGraphicsEffect(const std::string &name)
 {
-    auto it = impl->graphicsEffects.find(name);
+    auto it = getImpl()->graphicsEffects.find(name);
 
-    if (it == impl->graphicsEffects.cend())
+    if (it == getImpl()->graphicsEffects.cend())
         return nullptr;
     else
         return it->second.get();
@@ -76,5 +79,13 @@ int ScratchConfiguration::patchVersion()
 
 const std::vector<std::shared_ptr<IExtension>> ScratchConfiguration::getExtensions()
 {
-    return impl->extensions;
+    return getImpl()->extensions;
+}
+
+std::shared_ptr<ScratchConfigurationPrivate> &ScratchConfiguration::getImpl()
+{
+    if (!impl)
+        impl = std::make_unique<ScratchConfigurationPrivate>();
+
+    return impl;
 }
diff --git a/src/scratchconfiguration_p.cpp b/src/scratchconfiguration_p.cpp
index 10da258b..a9fd2d45 100644
--- a/src/scratchconfiguration_p.cpp
+++ b/src/scratchconfiguration_p.cpp
@@ -15,6 +15,11 @@ void ScratchConfigurationPrivate::registerExtension(std::shared_ptr<IExtension>
     extensions.push_back(extension);
 }
 
+void ScratchConfigurationPrivate::removeExtension(std::shared_ptr<IExtension> extension)
+{
+    extensions.erase(std::remove(extensions.begin(), extensions.end(), extension), extensions.end());
+}
+
 IExtension *ScratchConfigurationPrivate::getExtension(std::string name)
 {
     for (auto ext : extensions) {
diff --git a/src/scratchconfiguration_p.h b/src/scratchconfiguration_p.h
index 534d30c3..6747ef67 100644
--- a/src/scratchconfiguration_p.h
+++ b/src/scratchconfiguration_p.h
@@ -2,8 +2,6 @@
 
 #pragma once
 
-#include "blocks/standardblocks.h"
-
 #include <memory>
 #include <string>
 #include <vector>
@@ -19,10 +17,10 @@ class IGraphicsEffect;
 struct ScratchConfigurationPrivate
 {
         void registerExtension(std::shared_ptr<IExtension> extension);
+        void removeExtension(std::shared_ptr<IExtension> extension);
         IExtension *getExtension(std::string name);
 
-        std::vector<std::shared_ptr<IExtension>> extensions = { std::make_shared<StandardBlocks>() };
-        std::unordered_map<std::string, std::shared_ptr<IImageFormatFactory>> imageFormats;
+        std::vector<std::shared_ptr<IExtension>> extensions;
         std::unordered_map<std::string, std::shared_ptr<IGraphicsEffect>> graphicsEffects;
 };
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index cbf80d13..07771920 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -19,6 +19,7 @@ add_subdirectory(zip)
 add_subdirectory(load_project)
 add_subdirectory(project)
 add_subdirectory(compiler)
+add_subdirectory(thread)
 add_subdirectory(virtual_machine)
 add_subdirectory(scratch_classes)
 add_subdirectory(target_interfaces)
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
index 5fd8c636..f36b3e6b 100644
--- a/test/assets/sound_test.cpp
+++ b/test/assets/sound_test.cpp
@@ -84,9 +84,6 @@ 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);
 
@@ -102,13 +99,7 @@ TEST_F(SoundTest, SetEffect)
     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);
 
@@ -123,9 +114,6 @@ TEST_F(SoundTest, SetEffect)
 
     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)
@@ -238,7 +226,7 @@ TEST_F(SoundTest, Clone)
     EXPECT_CALL(engine, cloneLimit()).WillOnce(Return(-1));
     EXPECT_CALL(engine, initClone);
     EXPECT_CALL(engine, requestRedraw);
-    EXPECT_CALL(engine, moveSpriteBehindOther);
+    EXPECT_CALL(engine, moveDrawableBehindOther);
     auto spriteClone = sprite.clone();
 
     EXPECT_CALL(*anotherPlayer, setVolume).Times(2);
diff --git a/test/blocks/CMakeLists.txt b/test/blocks/CMakeLists.txt
index be6e69dd..3e32a0d0 100644
--- a/test/blocks/CMakeLists.txt
+++ b/test/blocks/CMakeLists.txt
@@ -1,159 +1,179 @@
-# variable_blocks_test
-add_executable(
-  variable_blocks_test
-  variable_blocks_test.cpp
-)
-
-target_link_libraries(
-  variable_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(variable_blocks_test)
-
-# list_blocks_test
-add_executable(
-  list_blocks_test
-  list_blocks_test.cpp
-)
-
-target_link_libraries(
-  list_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(list_blocks_test)
-
-# operator_blocks_test
-add_executable(
-  operator_blocks_test
-  operator_blocks_test.cpp
-)
+# motion_blocks_test
+if (LIBSCRATCHCPP_ENABLE_MOTION_BLOCKS)
+    add_executable(
+      motion_blocks_test
+      motion_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      motion_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(motion_blocks_test)
+endif()
 
-target_link_libraries(
-  operator_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
+# looks_blocks_test
+if (LIBSCRATCHCPP_ENABLE_LOOKS_BLOCKS)
+    add_executable(
+      looks_blocks_test
+      looks_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      looks_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(looks_blocks_test)
+endif()
 
-gtest_discover_tests(operator_blocks_test)
+# sound_blocks_test
+if (LIBSCRATCHCPP_ENABLE_SOUND_BLOCKS)
+    add_executable(
+      sound_blocks_test
+      sound_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      sound_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(sound_blocks_test)
+endif()
 
 # event_blocks_test
-add_executable(
-  event_blocks_test
-  event_blocks_test.cpp
-)
-
-target_link_libraries(
-  event_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(event_blocks_test)
+if (LIBSCRATCHCPP_ENABLE_EVENT_BLOCKS)
+    add_executable(
+      event_blocks_test
+      event_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      event_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(event_blocks_test)
+endif()
 
 # control_blocks_test
-add_executable(
-  control_blocks_test
-  control_blocks_test.cpp
-)
-
-target_link_libraries(
-  control_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(control_blocks_test)
-
-# custom_blocks_test
-add_executable(
-  custom_blocks_test
-  custom_blocks_test.cpp
-)
-
-target_link_libraries(
-  custom_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(custom_blocks_test)
+if (LIBSCRATCHCPP_ENABLE_CONTROL_BLOCKS)
+    add_executable(
+      control_blocks_test
+      control_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      control_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(control_blocks_test)
+endif()
 
 # sensing_blocks_test
-add_executable(
-  sensing_blocks_test
-  sensing_blocks_test.cpp
-)
-
-target_link_libraries(
-  sensing_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(sensing_blocks_test)
-
-# motion_blocks_test
-add_executable(
-  motion_blocks_test
-  motion_blocks_test.cpp
-)
+if (LIBSCRATCHCPP_ENABLE_SENSING_BLOCKS)
+    add_executable(
+      sensing_blocks_test
+      sensing_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      sensing_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(sensing_blocks_test)
+endif()
 
-target_link_libraries(
-  motion_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(motion_blocks_test)
-
-# looks_blocks_test
-add_executable(
-  looks_blocks_test
-  looks_blocks_test.cpp
-)
+# operator_blocks_test
+if (LIBSCRATCHCPP_ENABLE_OPERATOR_BLOCKS)
+    add_executable(
+      operator_blocks_test
+      operator_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      operator_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(operator_blocks_test)
+endif()
 
-target_link_libraries(
-  looks_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
+# variable_blocks_test
+if (LIBSCRATCHCPP_ENABLE_VARIABLE_BLOCKS)
+    add_executable(
+      variable_blocks_test
+      variable_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      variable_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(variable_blocks_test)
+endif()
 
-gtest_discover_tests(looks_blocks_test)
+# list_blocks_test
+if (LIBSCRATCHCPP_ENABLE_LIST_BLOCKS)
+    add_executable(
+      list_blocks_test
+      list_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      list_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(list_blocks_test)
+endif()
 
-# sound_blocks_test
-add_executable(
-  sound_blocks_test
-  sound_blocks_test.cpp
-)
-
-target_link_libraries(
-  sound_blocks_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(sound_blocks_test)
+# custom_blocks_test
+if (LIBSCRATCHCPP_ENABLE_CUSTOM_BLOCKS)
+    add_executable(
+      custom_blocks_test
+      custom_blocks_test.cpp
+    )
+
+    target_link_libraries(
+      custom_blocks_test
+      GTest::gtest_main
+      GTest::gmock_main
+      scratchcpp
+      scratchcpp_mocks
+    )
+
+    gtest_discover_tests(custom_blocks_test)
+endif()
diff --git a/test/blocks/control_blocks_test.cpp b/test/blocks/control_blocks_test.cpp
index a49acbea..6bb5e1ae 100644
--- a/test/blocks/control_blocks_test.cpp
+++ b/test/blocks/control_blocks_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/thread.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
@@ -24,8 +25,8 @@ class ControlBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<ControlBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<ControlBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         // For any control block
@@ -131,57 +132,52 @@ class ControlBlocksTest : public testing::Test
             return block;
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
 };
 
 TEST_F(ControlBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Control");
-}
-
-TEST_F(ControlBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Control");
 }
 
 TEST_F(ControlBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_forever", &ControlBlocks::compileRepeatForever)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_repeat", &ControlBlocks::compileRepeat)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_repeat_until", &ControlBlocks::compileRepeatUntil)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_while", &ControlBlocks::compileRepeatWhile)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_for_each", &ControlBlocks::compileRepeatForEach)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_if", &ControlBlocks::compileIfStatement)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_if_else", &ControlBlocks::compileIfElseStatement)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_stop", &ControlBlocks::compileStop)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_wait", &ControlBlocks::compileWait)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_wait_until", &ControlBlocks::compileWaitUntil)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_start_as_clone", &ControlBlocks::compileStartAsClone)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_create_clone_of", &ControlBlocks::compileCreateClone)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "control_delete_this_clone", &ControlBlocks::compileDeleteThisClone)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_forever", &ControlBlocks::compileRepeatForever)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_repeat", &ControlBlocks::compileRepeat)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_repeat_until", &ControlBlocks::compileRepeatUntil)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_while", &ControlBlocks::compileRepeatWhile)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_for_each", &ControlBlocks::compileRepeatForEach)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_if", &ControlBlocks::compileIfStatement)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_if_else", &ControlBlocks::compileIfElseStatement)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_stop", &ControlBlocks::compileStop)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_wait", &ControlBlocks::compileWait)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_wait_until", &ControlBlocks::compileWaitUntil)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_start_as_clone", &ControlBlocks::compileStartAsClone)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_create_clone_of", &ControlBlocks::compileCreateClone)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "control_delete_this_clone", &ControlBlocks::compileDeleteThisClone)).Times(1);
 
     // Inputs
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SUBSTACK", ControlBlocks::SUBSTACK));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SUBSTACK2", ControlBlocks::SUBSTACK2));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TIMES", ControlBlocks::TIMES));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "CONDITION", ControlBlocks::CONDITION));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DURATION", ControlBlocks::DURATION));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VALUE", ControlBlocks::VALUE));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "CLONE_OPTION", ControlBlocks::CLONE_OPTION));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "SUBSTACK", ControlBlocks::SUBSTACK));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "SUBSTACK2", ControlBlocks::SUBSTACK2));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "TIMES", ControlBlocks::TIMES));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "CONDITION", ControlBlocks::CONDITION));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "DURATION", ControlBlocks::DURATION));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "VALUE", ControlBlocks::VALUE));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "CLONE_OPTION", ControlBlocks::CLONE_OPTION));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "STOP_OPTION", ControlBlocks::STOP_OPTION));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "VARIABLE", ControlBlocks::VARIABLE));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "STOP_OPTION", ControlBlocks::STOP_OPTION));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "VARIABLE", ControlBlocks::VARIABLE));
 
     // Field values
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "all", ControlBlocks::StopAll));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "this script", ControlBlocks::StopThisScript));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "other scripts in sprite", ControlBlocks::StopOtherScriptsInSprite));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "all", ControlBlocks::StopAll));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "this script", ControlBlocks::StopThisScript));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "other scripts in sprite", ControlBlocks::StopOtherScriptsInSprite));
 
-    m_section->registerBlocks(&m_engineMock);
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(ControlBlocksTest, Forever)
@@ -704,14 +700,15 @@ TEST_F(ControlBlocksTest, StopOtherScriptsInSprite)
     static BlockFunc functions[] = { &ControlBlocks::stopOtherScriptsInSprite };
 
     Target target;
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setFunctions(functions);
-    vm.setBytecode(bytecode);
+    Thread thread(&target, &m_engineMock, nullptr);
+    VirtualMachine *vm = thread.vm();
+    vm->setFunctions(functions);
+    vm->setBytecode(bytecode);
 
-    EXPECT_CALL(m_engineMock, stopTarget(&target, &vm)).Times(1);
-    vm.run();
+    EXPECT_CALL(m_engineMock, stopTarget(&target, &thread)).Times(1);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
 }
 
 TEST_F(ControlBlocksTest, Wait)
@@ -908,7 +905,7 @@ TEST_F(ControlBlocksTest, CreateCloneOfImpl)
     EXPECT_CALL(m_engineMock, cloneLimit()).Times(8).WillRepeatedly(Return(300));
     EXPECT_CALL(m_engineMock, cloneCount()).Times(4).WillRepeatedly(Return(0));
     EXPECT_CALL(m_engineMock, initClone).WillOnce(SaveArg<0>(&clone1));
-    EXPECT_CALL(m_engineMock, moveSpriteBehindOther(_, &sprite));
+    EXPECT_CALL(m_engineMock, moveDrawableBehindOther(_, &sprite));
     EXPECT_CALL(m_engineMock, requestRedraw());
 
     vm.setBytecode(bytecode1);
@@ -918,7 +915,7 @@ TEST_F(ControlBlocksTest, CreateCloneOfImpl)
     ASSERT_EQ(sprite.clones().size(), 1);
 
     EXPECT_CALL(m_engineMock, initClone).Times(1);
-    EXPECT_CALL(m_engineMock, moveSpriteBehindOther(_, &sprite));
+    EXPECT_CALL(m_engineMock, moveDrawableBehindOther(_, &sprite));
     EXPECT_CALL(m_engineMock, requestRedraw());
 
     vm.setBytecode(bytecode2);
@@ -931,7 +928,7 @@ TEST_F(ControlBlocksTest, CreateCloneOfImpl)
     EXPECT_CALL(m_engineMock, findTarget).WillOnce(Return(4));
     EXPECT_CALL(m_engineMock, targetAt(4)).WillOnce(Return(&sprite));
     EXPECT_CALL(m_engineMock, initClone).WillOnce(SaveArg<0>(&clone3));
-    EXPECT_CALL(m_engineMock, moveSpriteBehindOther(_, &sprite));
+    EXPECT_CALL(m_engineMock, moveDrawableBehindOther(_, &sprite));
     EXPECT_CALL(m_engineMock, requestRedraw());
 
     vm.setBytecode(bytecode3);
@@ -941,7 +938,7 @@ TEST_F(ControlBlocksTest, CreateCloneOfImpl)
     ASSERT_EQ(sprite.clones().size(), 3);
 
     EXPECT_CALL(m_engineMock, initClone).Times(1);
-    EXPECT_CALL(m_engineMock, moveSpriteBehindOther(_, &sprite));
+    EXPECT_CALL(m_engineMock, moveDrawableBehindOther(_, &sprite));
     EXPECT_CALL(m_engineMock, requestRedraw());
 
     vm.setBytecode(bytecode4);
@@ -999,7 +996,7 @@ TEST_F(ControlBlocksTest, DeleteThisCloneImpl)
     EXPECT_CALL(m_engineMock, cloneLimit()).Times(2).WillRepeatedly(Return(300));
     EXPECT_CALL(m_engineMock, cloneCount()).WillOnce(Return(0));
     EXPECT_CALL(m_engineMock, initClone(_)).WillOnce(SaveArg<0>(&clone));
-    EXPECT_CALL(m_engineMock, moveSpriteBehindOther(_, &sprite));
+    EXPECT_CALL(m_engineMock, moveDrawableBehindOther(_, &sprite));
     EXPECT_CALL(m_engineMock, requestRedraw());
     sprite.clone();
     ASSERT_TRUE(clone);
diff --git a/test/blocks/custom_blocks_test.cpp b/test/blocks/custom_blocks_test.cpp
index d133cdb5..9f4e0f8e 100644
--- a/test/blocks/custom_blocks_test.cpp
+++ b/test/blocks/custom_blocks_test.cpp
@@ -17,8 +17,8 @@ class CustomBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<CustomBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<CustomBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         void addPrototypeInput(std::shared_ptr<Block> definitionBlock, std::shared_ptr<Block> prototypeBlock) const
@@ -36,36 +36,31 @@ class CustomBlocksTest : public testing::Test
             block->addInput(input);
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
 };
 
 TEST_F(CustomBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Custom blocks");
-}
-
-TEST_F(CustomBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Custom blocks");
 }
 
 TEST_F(CustomBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "procedures_definition", &CustomBlocks::compileDefinition)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "procedures_call", &CustomBlocks::compileCall)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "argument_reporter_boolean", &CustomBlocks::compileArgument)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "argument_reporter_string_number", &CustomBlocks::compileArgument)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "procedures_definition", &CustomBlocks::compileDefinition)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "procedures_call", &CustomBlocks::compileCall)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "argument_reporter_boolean", &CustomBlocks::compileArgument)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "argument_reporter_string_number", &CustomBlocks::compileArgument)).Times(1);
 
     // Inputs
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "custom_block", CustomBlocks::CUSTOM_BLOCK));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "custom_block", CustomBlocks::CUSTOM_BLOCK));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "VALUE", CustomBlocks::VALUE));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "VALUE", CustomBlocks::VALUE));
 
-    m_section->registerBlocks(&m_engineMock);
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(CustomBlocksTest, CustomBlocks)
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 5a6db769..e079aceb 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/thread.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/inputvalue.h>
@@ -27,8 +28,8 @@ class EventBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<EventBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<EventBlocks>();
+            m_extension->registerBlocks(&m_engine);
 
             m_broadcast = std::make_shared<Broadcast>("", "test");
             m_engine.setBroadcasts({ m_broadcast });
@@ -117,7 +118,7 @@ class EventBlocksTest : public testing::Test
             block->addField(field);
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
         std::shared_ptr<Broadcast> m_broadcast;
@@ -125,48 +126,43 @@ class EventBlocksTest : public testing::Test
 
 TEST_F(EventBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Events");
-}
-
-TEST_F(EventBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Events");
 }
 
 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));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcast", &EventBlocks::compileBroadcast));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcastandwait", &EventBlocks::compileBroadcastAndWait));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenbroadcastreceived", &EventBlocks::compileWhenBroadcastReceived));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenbackdropswitchesto", &EventBlocks::compileWhenBackdropSwitchesTo));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whengreaterthan", &EventBlocks::compileWhenGreaterThan));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenkeypressed", &EventBlocks::compileWhenKeyPressed));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_whentouchingobject", &EventBlocks::compileWhenTouchingObject));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_whenflagclicked", &EventBlocks::compileWhenFlagClicked));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_whenthisspriteclicked", &EventBlocks::compileWhenThisSpriteClicked));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_whenstageclicked", &EventBlocks::compileWhenStageClicked));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_broadcast", &EventBlocks::compileBroadcast));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_broadcastandwait", &EventBlocks::compileBroadcastAndWait));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_whenbroadcastreceived", &EventBlocks::compileWhenBroadcastReceived));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_whenbackdropswitchesto", &EventBlocks::compileWhenBackdropSwitchesTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "event_whengreaterthan", &EventBlocks::compileWhenGreaterThan));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.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));
+    EXPECT_CALL(m_engineMock, addHatPredicateCompileFunction(m_extension.get(), "event_whentouchingobject", &EventBlocks::compileWhenTouchingObjectPredicate));
+    EXPECT_CALL(m_engineMock, addHatPredicateCompileFunction(m_extension.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));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "TOUCHINGOBJECTMENU", EventBlocks::TOUCHINGOBJECTMENU));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "VALUE", EventBlocks::VALUE));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "BROADCAST_OPTION", EventBlocks::BROADCAST_OPTION));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "BACKDROP", EventBlocks::BACKDROP));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "WHENGREATERTHANMENU", EventBlocks::WHENGREATERTHANMENU));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "KEY_OPTION", EventBlocks::KEY_OPTION));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "BROADCAST_OPTION", EventBlocks::BROADCAST_OPTION));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "BACKDROP", EventBlocks::BACKDROP));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "WHENGREATERTHANMENU", EventBlocks::WHENGREATERTHANMENU));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "KEY_OPTION", EventBlocks::KEY_OPTION));
 
     // Field values
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "LOUDNESS", EventBlocks::Loudness));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "TIMER", EventBlocks::Timer));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "LOUDNESS", EventBlocks::Loudness));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "TIMER", EventBlocks::Timer));
 
-    m_section->registerBlocks(&m_engineMock);
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
@@ -373,9 +369,7 @@ TEST_F(EventBlocksTest, Broadcast)
     notBlock->setCompileFunction(&OperatorBlocks::compileNot);
     addObscuredInput(block2, "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT, notBlock);
 
-    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));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcast)).Times(2).WillRepeatedly(Return(0));
 
     compiler.init();
     compiler.setBlock(block1);
@@ -384,8 +378,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_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_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, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "test" }));
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
@@ -393,29 +387,22 @@ TEST_F(EventBlocksTest, Broadcast)
 TEST_F(EventBlocksTest, BroadcastImpl)
 {
     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[] = { &EventBlocks::broadcast, &EventBlocks::broadcastByIndex };
+    static BlockFunc functions[] = { &EventBlocks::broadcast };
     static Value constValues[] = { "test", 2 };
 
-    VirtualMachine vm(nullptr, &m_engineMock, nullptr);
-    vm.setFunctions(functions);
-    vm.setConstValues(constValues);
+    Thread thread(nullptr, &m_engineMock, nullptr);
+    VirtualMachine *vm = thread.vm();
+    vm->setFunctions(functions);
+    vm->setConstValues(constValues);
 
     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));
+    EXPECT_CALL(m_engineMock, broadcast(1, &thread, false));
+    EXPECT_CALL(m_engineMock, broadcast(4, &thread, false));
 
-    vm.setBytecode(bytecode1);
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
+    vm->setBytecode(bytecode1);
+    vm->run();
 
-    EXPECT_CALL(m_engineMock, broadcast(2)).Times(1);
-
-    vm.setBytecode(bytecode2);
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
 }
 
 TEST_F(EventBlocksTest, BroadcastAndWait)
@@ -432,11 +419,7 @@ TEST_F(EventBlocksTest, BroadcastAndWait)
     notBlock->setCompileFunction(&OperatorBlocks::compileNot);
     addObscuredInput(block2, "BROADCAST_INPUT", EventBlocks::BROADCAST_INPUT, notBlock);
 
-    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));
+    EXPECT_CALL(m_engineMock, functionIndex(&EventBlocks::broadcastAndWait)).Times(2).WillRepeatedly(Return(0));
 
     compiler.init();
     compiler.setBlock(block1);
@@ -445,86 +428,43 @@ TEST_F(EventBlocksTest, BroadcastAndWait)
     EventBlocks::compileBroadcastAndWait(&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, 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_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, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "test" }));
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_TRUE(compiler.lists().empty());
 }
 
 TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
 {
-    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, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 3, vm::OP_HALT };
-    static BlockFunc functions[] = { &EventBlocks::broadcastAndWait, &EventBlocks::checkBroadcast, &EventBlocks::broadcastByIndexAndWait, &EventBlocks::checkBroadcastByIndex };
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &EventBlocks::broadcastAndWait };
     static Value constValues[] = { "test", 3 };
 
-    VirtualMachine vm(nullptr, &m_engineMock, nullptr);
-    vm.setFunctions(functions);
-    vm.setConstValues(constValues);
+    Thread thread(nullptr, &m_engineMock, nullptr);
+    VirtualMachine *vm = thread.vm();
+    vm->setFunctions(functions);
+    vm->setConstValues(constValues);
 
     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, findBroadcasts("test")).WillOnce(Return(std::vector<int>({ 2, 3 })));
-    EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(true));
-
-    vm.setBytecode(bytecode2);
-    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(true));
-
-    vm.reset();
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 1);
-    ASSERT_EQ(vm.atEnd(), false);
+    EXPECT_CALL(m_engineMock, broadcast(1, &thread, true));
+    EXPECT_CALL(m_engineMock, broadcast(4, &thread, true));
 
-    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->setBytecode(bytecode);
+    vm->run();
 
-    vm.run();
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_FALSE(vm->atEnd());
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(vm.atEnd(), true);
+    vm->run();
 
-    EXPECT_CALL(m_engineMock, broadcast(3)).Times(1);
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_FALSE(vm->atEnd());
 
-    vm.setBytecode(bytecode3);
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-
-    EXPECT_CALL(m_engineMock, broadcastRunning(3)).WillOnce(Return(true));
-
-    vm.setBytecode(bytecode4);
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 1);
-    ASSERT_EQ(vm.atEnd(), false);
-
-    EXPECT_CALL(m_engineMock, broadcastRunning(3)).WillOnce(Return(false));
-
-    vm.run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(vm.atEnd(), true);
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_TRUE(vm->atEnd());
 }
 
 TEST_F(EventBlocksTest, WhenBroadcastReceived)
@@ -535,7 +475,7 @@ TEST_F(EventBlocksTest, WhenBroadcastReceived)
     auto block1 = createEventBlock("a", "event_whenbroadcastreceived");
     addBroadcastField(block1, "BROADCAST_OPTION", EventBlocks::BROADCAST_OPTION, m_broadcast);
 
-    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, EventBlocks::BROADCAST_OPTION, m_broadcast.get())).Times(1);
+    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, block1->fieldAt(0).get(), m_broadcast.get())).Times(1);
 
     compiler.init();
     compiler.setBlock(block1);
@@ -560,7 +500,7 @@ TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
     auto backdrop = std::make_shared<Costume>("backdrop2", "a", "svg");
     stage.addCostume(backdrop);
 
-    EXPECT_CALL(m_engineMock, addBackdropChangeScript(block1, EventBlocks::BACKDROP));
+    EXPECT_CALL(m_engineMock, addBackdropChangeScript(block1, block1->fieldAt(0).get()));
 
     compiler.init();
     compiler.setBlock(block1);
@@ -715,11 +655,11 @@ TEST_F(EventBlocksTest, WhenKeyPressed)
 
     compiler.init();
 
-    EXPECT_CALL(m_engineMock, addKeyPressScript(block1, EventBlocks::KEY_OPTION));
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block1, block1->fieldAt(0).get()));
     compiler.setBlock(block1);
     EventBlocks::compileWhenKeyPressed(&compiler);
 
-    EXPECT_CALL(m_engineMock, addKeyPressScript(block2, EventBlocks::KEY_OPTION));
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block2, block2->fieldAt(0).get()));
     compiler.setBlock(block2);
     EventBlocks::compileWhenKeyPressed(&compiler);
 
diff --git a/test/blocks/list_blocks_test.cpp b/test/blocks/list_blocks_test.cpp
index 40225cbc..90577da8 100644
--- a/test/blocks/list_blocks_test.cpp
+++ b/test/blocks/list_blocks_test.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/list.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/monitor.h>
 #include <enginemock.h>
@@ -20,8 +21,8 @@ class ListBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<ListBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<ListBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         // For any list block
@@ -80,48 +81,43 @@ class ListBlocksTest : public testing::Test
             return block;
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
 };
 
 TEST_F(ListBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Lists");
-}
-
-TEST_F(ListBlocksTest, CategoryVisible)
-{
-    ASSERT_FALSE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Lists");
 }
 
 TEST_F(ListBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_listcontents", &ListBlocks::compileListContents)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_addtolist", &ListBlocks::compileAddToList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_deleteoflist", &ListBlocks::compileDeleteFromList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_deletealloflist", &ListBlocks::compileDeleteAllOfList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_insertatlist", &ListBlocks::compileInsertToList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_replaceitemoflist", &ListBlocks::compileReplaceItemOfList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_itemoflist", &ListBlocks::compileItemOfList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_itemnumoflist", &ListBlocks::compileItemNumberInList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_lengthoflist", &ListBlocks::compileLengthOfList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_listcontainsitem", &ListBlocks::compileListContainsItem)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_showlist", &ListBlocks::compileShowList)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_hidelist", &ListBlocks::compileHideList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_listcontents", &ListBlocks::compileListContents)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_addtolist", &ListBlocks::compileAddToList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_deleteoflist", &ListBlocks::compileDeleteFromList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_deletealloflist", &ListBlocks::compileDeleteAllOfList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_insertatlist", &ListBlocks::compileInsertToList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_replaceitemoflist", &ListBlocks::compileReplaceItemOfList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_itemoflist", &ListBlocks::compileItemOfList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_itemnumoflist", &ListBlocks::compileItemNumberInList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_lengthoflist", &ListBlocks::compileLengthOfList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_listcontainsitem", &ListBlocks::compileListContainsItem)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_showlist", &ListBlocks::compileShowList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_hidelist", &ListBlocks::compileHideList)).Times(1);
 
     // Monitor names
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "data_listcontents", &ListBlocks::listContentsMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "data_listcontents", &ListBlocks::listContentsMonitorName));
 
     // Inputs
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "ITEM", ListBlocks::ITEM));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "INDEX", ListBlocks::INDEX));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "ITEM", ListBlocks::ITEM));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "INDEX", ListBlocks::INDEX));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "LIST", ListBlocks::LIST));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "LIST", ListBlocks::LIST));
 
-    m_section->registerBlocks(&m_engineMock);
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(ListBlocksTest, ListContents)
@@ -422,7 +418,7 @@ TEST_F(ListBlocksTest, ListContainsItem)
 
     // [list2] contains -Infinity
     auto list2 = std::make_shared<List>("d", "list2");
-    auto block2 = createListItemBlock("c", "data_listcontainsitem", list2, Value::SpecialValue::NegativeInfinity);
+    auto block2 = createListItemBlock("c", "data_listcontainsitem", list2, SpecialValue::NegativeInfinity);
 
     compiler.init();
     compiler.setBlock(block1);
@@ -432,7 +428,7 @@ TEST_F(ListBlocksTest, ListContainsItem)
     compiler.end();
 
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_LIST_CONTAINS, 0, vm::OP_CONST, 1, vm::OP_LIST_CONTAINS, 1, vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "hello world", Value(Value::SpecialValue::NegativeInfinity) }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "hello world", Value(SpecialValue::NegativeInfinity) }));
     ASSERT_TRUE(compiler.variables().empty());
     ASSERT_EQ(
         compiler.lists(),
@@ -498,8 +494,12 @@ TEST_F(ListBlocksTest, ShowListImpl)
     Stage stage;
     stage.addList(list1);
 
-    Target target;
-    target.addList(list2);
+    Sprite sprite;
+    sprite.addList(list2);
+
+    Engine fakeEngine;
+    sprite.setEngine(&fakeEngine);
+    auto clone = sprite.clone();
 
     // Global
     VirtualMachine vm1(&stage, &m_engineMock, nullptr);
@@ -526,7 +526,7 @@ TEST_F(ListBlocksTest, ShowListImpl)
     monitor1.setVisible(false);
 
     // Local
-    VirtualMachine vm2(&target, &m_engineMock, nullptr);
+    VirtualMachine vm2(&sprite, &m_engineMock, nullptr);
     vm2.setBytecode(bytecode3);
     vm2.setFunctions(functions);
     vm2.setConstValues(constValues);
@@ -543,6 +543,26 @@ TEST_F(ListBlocksTest, ShowListImpl)
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_FALSE(monitor1.visible());
     ASSERT_TRUE(monitor2.visible());
+
+    // Local - clone
+    monitor2.setVisible(false);
+    VirtualMachine vm3(clone.get(), &m_engineMock, nullptr);
+    vm3.setBytecode(bytecode3);
+    vm3.setFunctions(functions);
+    vm3.setConstValues(constValues);
+    vm3.run();
+
+    ASSERT_EQ(vm3.registerCount(), 0);
+    ASSERT_FALSE(monitor1.visible());
+    ASSERT_FALSE(monitor2.visible());
+
+    vm3.reset();
+    vm3.setBytecode(bytecode4);
+    vm3.run();
+
+    ASSERT_EQ(vm3.registerCount(), 0);
+    ASSERT_FALSE(monitor1.visible());
+    ASSERT_TRUE(monitor2.visible());
 }
 
 TEST_F(ListBlocksTest, HideList)
@@ -601,8 +621,12 @@ TEST_F(ListBlocksTest, HideListImpl)
     Stage stage;
     stage.addList(list1);
 
-    Target target;
-    target.addList(list2);
+    Sprite sprite;
+    sprite.addList(list2);
+
+    Engine fakeEngine;
+    sprite.setEngine(&fakeEngine);
+    auto clone = sprite.clone();
 
     // Global
     VirtualMachine vm1(&stage, &m_engineMock, nullptr);
@@ -629,7 +653,7 @@ TEST_F(ListBlocksTest, HideListImpl)
     monitor1.setVisible(true);
 
     // Local
-    VirtualMachine vm2(&target, &m_engineMock, nullptr);
+    VirtualMachine vm2(&sprite, &m_engineMock, nullptr);
     vm2.setBytecode(bytecode3);
     vm2.setFunctions(functions);
     vm2.setConstValues(constValues);
@@ -646,4 +670,24 @@ TEST_F(ListBlocksTest, HideListImpl)
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_TRUE(monitor1.visible());
     ASSERT_FALSE(monitor2.visible());
+
+    // Local - clone
+    monitor2.setVisible(true);
+    VirtualMachine vm3(clone.get(), &m_engineMock, nullptr);
+    vm3.setBytecode(bytecode3);
+    vm3.setFunctions(functions);
+    vm3.setConstValues(constValues);
+    vm3.run();
+
+    ASSERT_EQ(vm3.registerCount(), 0);
+    ASSERT_TRUE(monitor1.visible());
+    ASSERT_TRUE(monitor2.visible());
+
+    vm3.reset();
+    vm3.setBytecode(bytecode4);
+    vm3.run();
+
+    ASSERT_EQ(vm3.registerCount(), 0);
+    ASSERT_TRUE(monitor1.visible());
+    ASSERT_FALSE(monitor2.visible());
 }
diff --git a/test/blocks/looks_blocks_test.cpp b/test/blocks/looks_blocks_test.cpp
index 950187b7..92c21532 100644
--- a/test/blocks/looks_blocks_test.cpp
+++ b/test/blocks/looks_blocks_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/thread.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
@@ -21,14 +22,16 @@
 using namespace libscratchcpp;
 
 using ::testing::Return;
+using ::testing::ReturnArg;
+using ::testing::_;
 
 class LooksBlocksTest : public testing::Test
 {
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<LooksBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<LooksBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         // For any looks block
@@ -89,82 +92,78 @@ class LooksBlocksTest : public testing::Test
             block->addField(field);
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
 };
 
 TEST_F(LooksBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Looks");
-}
-
-TEST_F(LooksBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Looks");
 }
 
 TEST_F(LooksBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_sayforsecs", &LooksBlocks::compileSayForSecs));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_say", &LooksBlocks::compileSay));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_thinkforsecs", &LooksBlocks::compileThinkForSecs));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_think", &LooksBlocks::compileThink));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_show", &LooksBlocks::compileShow));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_hide", &LooksBlocks::compileHide));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_changeeffectby", &LooksBlocks::compileChangeEffectBy));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_seteffectto", &LooksBlocks::compileSetEffectTo));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_cleargraphiceffects", &LooksBlocks::compileClearGraphicEffects));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_changesizeby", &LooksBlocks::compileChangeSizeBy));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_setsizeto", &LooksBlocks::compileSetSizeTo));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_size", &LooksBlocks::compileSize));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_switchcostumeto", &LooksBlocks::compileSwitchCostumeTo));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_nextcostume", &LooksBlocks::compileNextCostume));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_switchbackdropto", &LooksBlocks::compileSwitchBackdropTo));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_switchbackdroptoandwait", &LooksBlocks::compileSwitchBackdropToAndWait));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_nextbackdrop", &LooksBlocks::compileNextBackdrop));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_gotofrontback", &LooksBlocks::compileGoToFrontBack));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_goforwardbackwardlayers", &LooksBlocks::compileGoForwardBackwardLayers));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_costumenumbername", &LooksBlocks::compileCostumeNumberName));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "looks_backdropnumbername", &LooksBlocks::compileBackdropNumberName));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_sayforsecs", &LooksBlocks::compileSayForSecs));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_say", &LooksBlocks::compileSay));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_thinkforsecs", &LooksBlocks::compileThinkForSecs));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_think", &LooksBlocks::compileThink));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_show", &LooksBlocks::compileShow));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_hide", &LooksBlocks::compileHide));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_changeeffectby", &LooksBlocks::compileChangeEffectBy));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_seteffectto", &LooksBlocks::compileSetEffectTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_cleargraphiceffects", &LooksBlocks::compileClearGraphicEffects));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_changesizeby", &LooksBlocks::compileChangeSizeBy));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_setsizeto", &LooksBlocks::compileSetSizeTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_size", &LooksBlocks::compileSize));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_switchcostumeto", &LooksBlocks::compileSwitchCostumeTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_nextcostume", &LooksBlocks::compileNextCostume));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_switchbackdropto", &LooksBlocks::compileSwitchBackdropTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_switchbackdroptoandwait", &LooksBlocks::compileSwitchBackdropToAndWait));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_nextbackdrop", &LooksBlocks::compileNextBackdrop));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_gotofrontback", &LooksBlocks::compileGoToFrontBack));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_goforwardbackwardlayers", &LooksBlocks::compileGoForwardBackwardLayers));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_costumenumbername", &LooksBlocks::compileCostumeNumberName));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "looks_backdropnumbername", &LooksBlocks::compileBackdropNumberName));
 
     // Monitor names
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "looks_costumenumbername", &LooksBlocks::costumeNumberNameMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "looks_backdropnumbername", &LooksBlocks::backdropNumberNameMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "looks_size", &LooksBlocks::sizeMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "looks_costumenumbername", &LooksBlocks::costumeNumberNameMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "looks_backdropnumbername", &LooksBlocks::backdropNumberNameMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "looks_size", &LooksBlocks::sizeMonitorName));
 
     // Inputs
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "MESSAGE", LooksBlocks::MESSAGE));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SECS", LooksBlocks::SECS));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "CHANGE", LooksBlocks::CHANGE));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SIZE", LooksBlocks::SIZE));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "COSTUME", LooksBlocks::COSTUME));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "BACKDROP", LooksBlocks::BACKDROP));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VALUE", LooksBlocks::VALUE));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "MESSAGE", LooksBlocks::MESSAGE));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "SECS", LooksBlocks::SECS));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "CHANGE", LooksBlocks::CHANGE));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "SIZE", LooksBlocks::SIZE));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "COSTUME", LooksBlocks::COSTUME));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "BACKDROP", LooksBlocks::BACKDROP));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "VALUE", LooksBlocks::VALUE));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "NUM", LooksBlocks::NUM));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "NUMBER_NAME", LooksBlocks::NUMBER_NAME));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "EFFECT", LooksBlocks::EFFECT));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "FRONT_BACK", LooksBlocks::FRONT_BACK));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "FORWARD_BACKWARD", LooksBlocks::FORWARD_BACKWARD));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "NUMBER_NAME", LooksBlocks::NUMBER_NAME));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "EFFECT", LooksBlocks::EFFECT));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "FRONT_BACK", LooksBlocks::FRONT_BACK));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "FORWARD_BACKWARD", LooksBlocks::FORWARD_BACKWARD));
 
     // Field values
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "number", LooksBlocks::Number));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "name", LooksBlocks::Name));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "COLOR", LooksBlocks::ColorEffect));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "FISHEYE", LooksBlocks::FisheyeEffect));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "WHIRL", LooksBlocks::WhirlEffect));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "PIXELATE", LooksBlocks::PixelateEffect));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "MOSAIC", LooksBlocks::MosaicEffect));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "BRIGHTNESS", LooksBlocks::BrightnessEffect));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "GHOST", LooksBlocks::GhostEffect));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "front", LooksBlocks::Front));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "back", LooksBlocks::Back));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "forward", LooksBlocks::Forward));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "backward", LooksBlocks::Backward));
-
-    m_section->registerBlocks(&m_engineMock);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "number", LooksBlocks::Number));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "name", LooksBlocks::Name));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "COLOR", LooksBlocks::ColorEffect));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "FISHEYE", LooksBlocks::FisheyeEffect));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "WHIRL", LooksBlocks::WhirlEffect));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "PIXELATE", LooksBlocks::PixelateEffect));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "MOSAIC", LooksBlocks::MosaicEffect));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "BRIGHTNESS", LooksBlocks::BrightnessEffect));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "GHOST", LooksBlocks::GhostEffect));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "front", LooksBlocks::Front));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "back", LooksBlocks::Back));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "forward", LooksBlocks::Forward));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "backward", LooksBlocks::Backward));
+
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(LooksBlocksTest, SayForSecs)
@@ -197,7 +196,7 @@ TEST_F(LooksBlocksTest, SayForSecsImpl)
     static Value constValues[] = { "test", 5.5, "hello" };
 
     Target target;
-    target.setBubbleType(Target::BubbleType::Think);
+    target.bubble()->setType(TextBubble::Type::Think);
     VirtualMachine vm(&target, &m_engineMock, nullptr);
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
@@ -214,20 +213,20 @@ TEST_F(LooksBlocksTest, SayForSecsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) != LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     std::chrono::steady_clock::time_point time1(std::chrono::milliseconds(6450));
     EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time1));
-    target.setBubbleType(Target::BubbleType::Think);
-    target.setBubbleText("another");
+    target.bubble()->setType(TextBubble::Type::Think);
+    target.bubble()->setText("another");
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) != LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "another");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "another");
 
     std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(6500));
     EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
@@ -236,16 +235,16 @@ TEST_F(LooksBlocksTest, SayForSecsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) == LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_TRUE(target.bubbleText().empty());
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_TRUE(target.bubble()->text().empty());
 
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) == LooksBlocks::m_timeMap.cend());
     ASSERT_TRUE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_TRUE(target.bubbleText().empty());
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_TRUE(target.bubble()->text().empty());
 
     // Run the say block while waiting
     VirtualMachine vm2(&target, &m_engineMock, nullptr);
@@ -261,12 +260,12 @@ TEST_F(LooksBlocksTest, SayForSecsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) != LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     vm2.run();
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "hello");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "hello");
 
     EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
     vm.run();
@@ -274,16 +273,16 @@ TEST_F(LooksBlocksTest, SayForSecsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) == LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "hello");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "hello");
 
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) == LooksBlocks::m_timeMap.cend());
     ASSERT_TRUE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "hello");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "hello");
 
     // Run the say for secs block while waiting
     vm2.reset();
@@ -297,15 +296,15 @@ TEST_F(LooksBlocksTest, SayForSecsImpl)
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm2) != LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm2.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "hello");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "hello");
 
     EXPECT_CALL(clock, currentSteadyTime()).Times(2).WillRepeatedly(Return(startTime));
     EXPECT_CALL(m_engineMock, requestRedraw());
     vm.reset();
     vm.run();
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
     vm2.run();
@@ -313,16 +312,16 @@ TEST_F(LooksBlocksTest, SayForSecsImpl)
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm2) == LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm2.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     vm2.run();
 
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm2) == LooksBlocks::m_timeMap.cend());
     ASSERT_TRUE(vm2.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     LooksBlocks::clock = Clock::instance().get();
 }
@@ -361,16 +360,16 @@ TEST_F(LooksBlocksTest, SayImpl)
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
-    target.setBubbleType(Target::BubbleType::Think);
+    target.bubble()->setType(TextBubble::Type::Think);
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "test");
 }
 
 TEST_F(LooksBlocksTest, ThinkForSecs)
@@ -403,7 +402,7 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     static Value constValues[] = { "test", 5.5, "hello" };
 
     Target target;
-    target.setBubbleType(Target::BubbleType::Say);
+    target.bubble()->setType(TextBubble::Type::Say);
     VirtualMachine vm(&target, &m_engineMock, nullptr);
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
@@ -420,20 +419,20 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) != LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     std::chrono::steady_clock::time_point time1(std::chrono::milliseconds(6450));
     EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time1));
-    target.setBubbleType(Target::BubbleType::Say);
-    target.setBubbleText("another");
+    target.bubble()->setType(TextBubble::Type::Say);
+    target.bubble()->setText("another");
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) != LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleText(), "another");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(target.bubble()->text(), "another");
 
     std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(6500));
     EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
@@ -442,16 +441,16 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) == LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_TRUE(target.bubbleText().empty());
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_TRUE(target.bubble()->text().empty());
 
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) == LooksBlocks::m_timeMap.cend());
     ASSERT_TRUE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-    ASSERT_TRUE(target.bubbleText().empty());
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_TRUE(target.bubble()->text().empty());
 
     // Run the say block while waiting
     VirtualMachine vm2(&target, &m_engineMock, nullptr);
@@ -467,12 +466,12 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) != LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     vm2.run();
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "hello");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "hello");
 
     EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
     vm.run();
@@ -480,16 +479,16 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) == LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "hello");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "hello");
 
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm) == LooksBlocks::m_timeMap.cend());
     ASSERT_TRUE(vm.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "hello");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "hello");
 
     // Run the say for secs block while waiting
     vm2.reset();
@@ -503,15 +502,15 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm2) != LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm2.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "hello");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "hello");
 
     EXPECT_CALL(clock, currentSteadyTime()).Times(2).WillRepeatedly(Return(startTime));
     EXPECT_CALL(m_engineMock, requestRedraw());
     vm.reset();
     vm.run();
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time2));
     vm2.run();
@@ -519,16 +518,16 @@ TEST_F(LooksBlocksTest, ThinkForSecsImpl)
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm2) == LooksBlocks::m_timeMap.cend());
     ASSERT_FALSE(vm2.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     vm2.run();
 
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_TRUE(LooksBlocks::m_timeMap.find(&vm2) == LooksBlocks::m_timeMap.cend());
     ASSERT_TRUE(vm2.atEnd());
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
     LooksBlocks::clock = Clock::instance().get();
 }
@@ -567,16 +566,16 @@ TEST_F(LooksBlocksTest, ThinkImpl)
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "test");
 
-    target.setBubbleType(Target::BubbleType::Say);
+    target.bubble()->setType(TextBubble::Type::Say);
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleText(), "test");
+    ASSERT_EQ(target.bubble()->type(), TextBubble::Type::Think);
+    ASSERT_EQ(target.bubble()->text(), "test");
 }
 
 TEST_F(LooksBlocksTest, Show)
@@ -861,6 +860,14 @@ static void initEffects()
     LooksBlocks::m_mosaicEffect = ScratchConfiguration::getGraphicsEffect("mosaic");
     LooksBlocks::m_brightnessEffect = ScratchConfiguration::getGraphicsEffect("brightness");
     LooksBlocks::m_ghostEffect = ScratchConfiguration::getGraphicsEffect("ghost");
+
+    EXPECT_CALL(*colorEffect, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(*fisheyeEffect, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(*whirlEffect, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(*pixelateEffect, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(*mosaicEffect, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(*brightnessEffect, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(*ghostEffect, clamp(_)).WillRepeatedly(ReturnArg<0>());
 }
 
 static void removeEffects()
@@ -892,6 +899,8 @@ TEST_F(LooksBlocksTest, ChangeEffectByImpl)
     static Value constValues[] = { 0, 55.15, 1, -40.54, 1.2, 2.3, -3.4, -4.5, 0.5, -8.54, 0.01 };
 
     GraphicsEffectMock effect1, effect2;
+    EXPECT_CALL(effect1, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(effect2, clamp(_)).WillRepeatedly(ReturnArg<0>());
 
     Target target;
     target.setGraphicsEffectValue(&effect1, 12.5);
@@ -1168,6 +1177,8 @@ TEST_F(LooksBlocksTest, SetEffectToImpl)
     static Value constValues[] = { 0, 55.15, 1, -40.54, 1.2, 2.3, -3.4, -4.5, 0.5, -8.54, 0.01 };
 
     GraphicsEffectMock effect1, effect2;
+    EXPECT_CALL(effect1, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(effect2, clamp(_)).WillRepeatedly(ReturnArg<0>());
 
     Target target;
     target.setGraphicsEffectValue(&effect1, 12.5);
@@ -1287,6 +1298,8 @@ TEST_F(LooksBlocksTest, ClearGraphicEffectsImpl)
 
     Target target;
     GraphicsEffectMock effect1, effect2;
+    EXPECT_CALL(effect1, clamp(_)).WillRepeatedly(ReturnArg<0>());
+    EXPECT_CALL(effect2, clamp(_)).WillRepeatedly(ReturnArg<0>());
     target.setGraphicsEffectValue(&effect1, 48.21);
     target.setGraphicsEffectValue(&effect2, -107.08);
 
@@ -1426,159 +1439,24 @@ TEST_F(LooksBlocksTest, SwitchCostumeTo)
     auto block1 = std::make_shared<Block>("a", "looks_switchcostumeto");
     addDropdownInput(block1, "COSTUME", LooksBlocks::COSTUME, "costume2");
 
-    // switch costume to (0)
-    auto block2 = std::make_shared<Block>("b", "looks_switchcostumeto");
-    addDropdownInput(block2, "COSTUME", LooksBlocks::COSTUME, "0");
-
-    // switch costume to (1)
-    auto block3 = std::make_shared<Block>("b", "looks_switchcostumeto");
-    addDropdownInput(block3, "COSTUME", LooksBlocks::COSTUME, "1");
-
-    // switch costume to (2)
-    auto block4 = std::make_shared<Block>("b", "looks_switchcostumeto");
-    addDropdownInput(block4, "COSTUME", LooksBlocks::COSTUME, "2");
-
-    // switch costume to (4)
-    auto block5 = std::make_shared<Block>("b", "looks_switchcostumeto");
-    addDropdownInput(block5, "COSTUME", LooksBlocks::COSTUME, "4");
-
-    // switch costume to (3) - there's a costume with this name
-    auto block6 = std::make_shared<Block>("c", "looks_switchcostumeto");
-    addDropdownInput(block6, "COSTUME", LooksBlocks::COSTUME, "3");
-
-    // switch costume to (next costume)
-    auto block7 = std::make_shared<Block>("d", "looks_switchcostumeto");
-    addDropdownInput(block7, "COSTUME", LooksBlocks::COSTUME, "next costume");
-
-    // switch costume to (next costume) - there's a costume with this name
-    auto block8 = std::make_shared<Block>("d", "looks_switchcostumeto");
-    addDropdownInput(block8, "COSTUME", LooksBlocks::COSTUME, "next costume");
-
-    // switch costume to (previous costume)
-    auto block9 = std::make_shared<Block>("e", "looks_switchcostumeto");
-    addDropdownInput(block9, "COSTUME", LooksBlocks::COSTUME, "previous costume");
-
-    // switch costume to (previous costume) - there's a costume with this name
-    auto block10 = std::make_shared<Block>("f", "looks_switchcostumeto");
-    addDropdownInput(block10, "COSTUME", LooksBlocks::COSTUME, "previous costume");
-
     // switch costume to (null block)
-    auto block11 = std::make_shared<Block>("g", "looks_switchcostumeto");
-    addDropdownInput(block11, "COSTUME", LooksBlocks::COSTUME, "", createNullBlock("h"));
+    auto block2 = std::make_shared<Block>("b", "looks_switchcostumeto");
+    addDropdownInput(block2, "COSTUME", LooksBlocks::COSTUME, "", createNullBlock("c"));
 
     compiler.init();
 
-    // Test without any costumes first
-    compiler.setBlock(block1);
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeTo)).WillOnce(Return(3));
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    target.addCostume(std::make_shared<Costume>("costume1", "c1", "svg"));
-    target.addCostume(std::make_shared<Costume>("costume2", "c2", "svg"));
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeToByIndex)).WillOnce(Return(0));
     compiler.setBlock(block1);
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeTo)).WillOnce(Return(0));
     LooksBlocks::compileSwitchCostumeTo(&compiler);
 
-    target.addCostume(std::make_shared<Costume>("costume3", "c3", "svg"));
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeTo)).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeTo)).WillOnce(Return(0));
     compiler.setBlock(block2);
     LooksBlocks::compileSwitchCostumeTo(&compiler);
 
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeTo)).WillOnce(Return(3));
-    compiler.setBlock(block3);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeTo)).WillOnce(Return(3));
-    compiler.setBlock(block4);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeTo)).WillOnce(Return(3));
-    compiler.setBlock(block5);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    target.addCostume(std::make_shared<Costume>("3", "c4", "svg"));
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeToByIndex)).WillOnce(Return(0));
-    compiler.setBlock(block6);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::nextCostume)).WillOnce(Return(1));
-    compiler.setBlock(block7);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    target.addCostume(std::make_shared<Costume>("next costume", "c5", "svg"));
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeToByIndex)).WillOnce(Return(0));
-    compiler.setBlock(block8);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::previousCostume)).WillOnce(Return(2));
-    compiler.setBlock(block9);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    target.addCostume(std::make_shared<Costume>("previous costume", "c6", "svg"));
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeToByIndex)).WillOnce(Return(0));
-    compiler.setBlock(block10);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchCostumeTo)).WillOnce(Return(3));
-    compiler.setBlock(block11);
-    LooksBlocks::compileSwitchCostumeTo(&compiler);
-
     compiler.end();
 
-    ASSERT_EQ(
-        compiler.bytecode(),
-        std::vector<unsigned int>(
-            { vm::OP_START,
-              vm::OP_CONST,
-              0,
-              vm::OP_EXEC,
-              3,
-              vm::OP_CONST,
-              1,
-              vm::OP_EXEC,
-              0,
-              vm::OP_CONST,
-              2,
-              vm::OP_EXEC,
-              3,
-              vm::OP_CONST,
-              3,
-              vm::OP_EXEC,
-              3,
-              vm::OP_CONST,
-              4,
-              vm::OP_EXEC,
-              3,
-              vm::OP_CONST,
-              5,
-              vm::OP_EXEC,
-              3,
-              vm::OP_CONST,
-              6,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              1,
-              vm::OP_CONST,
-              7,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              2,
-              vm::OP_CONST,
-              8,
-              vm::OP_EXEC,
-              0,
-              vm::OP_NULL,
-              vm::OP_EXEC,
-              3,
-              vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "costume2", 1, "0", "1", "2", "4", 3, 4, 5 }));
+    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(), std::vector<Value>({ "costume2" }));
 }
 
 TEST_F(LooksBlocksTest, SwitchCostumeToImpl)
@@ -1588,15 +1466,17 @@ TEST_F(LooksBlocksTest, SwitchCostumeToImpl)
     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 unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 1, vm::OP_HALT };
-    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 1, vm::OP_HALT };
-    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 1, vm::OP_HALT };
-    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::switchCostumeTo, &LooksBlocks::switchCostumeToByIndex };
-    static Value constValues[] = { "costume2", 0, 1, 2, 3, "next costume", "previous costume", -1, 0, 5, 6 };
+    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 11, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode13[] = { vm::OP_START, vm::OP_CONST, 12, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode14[] = { vm::OP_START, vm::OP_CONST, 13, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::switchCostumeTo };
+    static Value constValues[] = { "costume2", 0, 1, 2, 3, "2", "3", SpecialValue::NaN, SpecialValue::Infinity, SpecialValue::NegativeInfinity, "", "   ", "next costume", "previous costume" };
 
     Target target;
     target.addCostume(std::make_shared<Costume>("costume1", "c1", "svg"));
@@ -1652,102 +1532,135 @@ TEST_F(LooksBlocksTest, SwitchCostumeToImpl)
 
     target.setCostumeIndex(1);
 
-    // "2"
+    // 2
     target.addCostume(std::make_shared<Costume>("2", "c3", "svg"));
     target.addCostume(std::make_shared<Costume>("test", "c4", "svg"));
     target.setCostumeIndex(0);
 
+    vm.setBytecode(bytecode4);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(target.costumeIndex(), 1);
+
+    // "2"
+    target.setCostumeIndex(0);
+
     vm.setBytecode(bytecode6);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(target.costumeIndex(), 2);
 
-    // "next costume"
+    // "3"
+    target.setCostumeIndex(0);
+
     vm.setBytecode(bytecode7);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 3);
+    ASSERT_EQ(target.costumeIndex(), 2);
 
-    vm.reset();
+    // NaN
+    target.setCostumeIndex(2);
+
+    vm.setBytecode(bytecode8);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(target.costumeIndex(), 0);
 
-    vm.reset();
+    // Infinity
+    target.setCostumeIndex(2);
+
+    vm.setBytecode(bytecode9);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 1);
+    ASSERT_EQ(target.costumeIndex(), 0);
 
-    target.addCostume(std::make_shared<Costume>("next costume", "c5", "svg"));
+    // -Infinity
+    target.setCostumeIndex(2);
 
-    vm.reset();
+    vm.setBytecode(bytecode10);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 4);
+    ASSERT_EQ(target.costumeIndex(), 0);
 
-    // "previous costume"
-    vm.setBytecode(bytecode8);
+    // ""
+    target.setCostumeIndex(2);
+
+    vm.setBytecode(bytecode11);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 3);
+    ASSERT_EQ(target.costumeIndex(), 2);
 
-    vm.reset();
+    // "   "
+    target.setCostumeIndex(2);
+
+    vm.setBytecode(bytecode12);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(target.costumeIndex(), 2);
 
-    target.setCostumeIndex(0);
+    // "next costume"
+    vm.setBytecode(bytecode13);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(target.costumeIndex(), 3);
 
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 4);
-
-    target.addCostume(std::make_shared<Costume>("previous costume", "c6", "svg"));
+    ASSERT_EQ(target.costumeIndex(), 0);
 
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 5);
+    ASSERT_EQ(target.costumeIndex(), 1);
 
-    // -1 (index)
-    target.setCostumeIndex(1);
+    target.addCostume(std::make_shared<Costume>("next costume", "c5", "svg"));
 
-    vm.setBytecode(bytecode9);
+    vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 5);
+    ASSERT_EQ(target.costumeIndex(), 4);
 
-    // 0 (index)
-    vm.setBytecode(bytecode10);
+    // "previous costume"
+    vm.setBytecode(bytecode14);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 0);
+    ASSERT_EQ(target.costumeIndex(), 3);
 
-    // 5 (index)
-    vm.setBytecode(bytecode11);
+    vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 5);
+    ASSERT_EQ(target.costumeIndex(), 2);
 
-    // 6 (index)
-    vm.setBytecode(bytecode12);
+    target.setCostumeIndex(0);
+
+    vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(target.costumeIndex(), 0);
+    ASSERT_EQ(target.costumeIndex(), 4);
+
+    target.addCostume(std::make_shared<Costume>("previous costume", "c6", "svg"));
+
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(target.costumeIndex(), 5);
 }
 
 TEST_F(LooksBlocksTest, NextCostume)
@@ -1834,718 +1747,330 @@ TEST_F(LooksBlocksTest, PreviousCostume)
 TEST_F(LooksBlocksTest, SwitchBackdropTo)
 {
     Target target;
-    Stage stage;
     Compiler compiler(&m_engineMock, &target);
 
     // switch backdrop to (backdrop2)
     auto block1 = std::make_shared<Block>("a", "looks_switchbackdropto");
     addDropdownInput(block1, "BACKDROP", LooksBlocks::BACKDROP, "backdrop2");
 
-    // switch backdrop to (0)
+    // switch backdrop to (null block)
     auto block2 = std::make_shared<Block>("b", "looks_switchbackdropto");
-    addDropdownInput(block2, "BACKDROP", LooksBlocks::BACKDROP, "0");
+    addDropdownInput(block2, "BACKDROP", LooksBlocks::BACKDROP, "", createNullBlock("c"));
 
-    // switch backdrop to (1)
-    auto block3 = std::make_shared<Block>("b", "looks_switchbackdropto");
-    addDropdownInput(block3, "BACKDROP", LooksBlocks::BACKDROP, "1");
+    compiler.init();
 
-    // switch backdrop to (2)
-    auto block4 = std::make_shared<Block>("b", "looks_switchbackdropto");
-    addDropdownInput(block4, "BACKDROP", LooksBlocks::BACKDROP, "2");
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropTo)).WillOnce(Return(0));
+    compiler.setBlock(block1);
+    LooksBlocks::compileSwitchBackdropTo(&compiler);
 
-    // switch backdrop to (4)
-    auto block5 = std::make_shared<Block>("b", "looks_switchbackdropto");
-    addDropdownInput(block5, "BACKDROP", LooksBlocks::BACKDROP, "4");
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropTo)).WillOnce(Return(0));
+    compiler.setBlock(block2);
+    LooksBlocks::compileSwitchBackdropTo(&compiler);
 
-    // switch backdrop to (3) - there's a backdrop with this name
-    auto block6 = std::make_shared<Block>("c", "looks_switchbackdropto");
-    addDropdownInput(block6, "BACKDROP", LooksBlocks::BACKDROP, "3");
+    compiler.end();
 
-    // switch backdrop to (next backdrop)
-    auto block7 = std::make_shared<Block>("d", "looks_switchbackdropto");
-    addDropdownInput(block7, "BACKDROP", LooksBlocks::BACKDROP, "next backdrop");
+    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(), std::vector<Value>({ "backdrop2" }));
+}
 
-    // switch backdrop to (next backdrop) - there's a backdrop with this name
-    auto block8 = std::make_shared<Block>("d", "looks_switchbackdropto");
-    addDropdownInput(block8, "BACKDROP", LooksBlocks::BACKDROP, "next backdrop");
+TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
+{
+    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 unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 11, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode13[] = { vm::OP_START, vm::OP_CONST, 12, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode14[] = { vm::OP_START, vm::OP_CONST, 13, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode15[] = { vm::OP_START, vm::OP_CONST, 14, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::switchBackdropTo };
+    static Value constValues[] = {
+        "backdrop2", 0, 1, 2, 3, "2", "3", SpecialValue::NaN, SpecialValue::Infinity, SpecialValue::NegativeInfinity, "", "   ", "next backdrop", "previous backdrop", "random backdrop"
+    };
 
-    // switch backdrop to (previous backdrop)
-    auto block9 = std::make_shared<Block>("e", "looks_switchbackdropto");
-    addDropdownInput(block9, "BACKDROP", LooksBlocks::BACKDROP, "previous backdrop");
+    Target target;
 
-    // switch backdrop to (previous backdrop) - there's a backdrop with this name
-    auto block10 = std::make_shared<Block>("f", "looks_switchbackdropto");
-    addDropdownInput(block10, "BACKDROP", LooksBlocks::BACKDROP, "previous backdrop");
+    Stage stage;
+    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
+    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
+    stage.setCostumeIndex(0);
+    EXPECT_CALL(m_engineMock, stage()).WillRepeatedly(Return(&stage));
 
-    // switch backdrop to (random backdrop)
-    auto block11 = std::make_shared<Block>("g", "looks_switchbackdropto");
-    addDropdownInput(block11, "BACKDROP", LooksBlocks::BACKDROP, "random backdrop");
+    Thread thread(&target, &m_engineMock, nullptr);
+    VirtualMachine *vm = thread.vm();
+    vm->setFunctions(functions);
+    vm->setConstValues(constValues);
 
-    // switch backdrop to (random backdrop) - there's a backdrop with this name
-    auto block12 = std::make_shared<Block>("h", "looks_switchbackdropto");
-    addDropdownInput(block12, "BACKDROP", LooksBlocks::BACKDROP, "random backdrop");
+    // "backdrop2"
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, false));
+    vm->setBytecode(bytecode1);
+    vm->run();
 
-    // switch backdrop to (null block)
-    auto block13 = std::make_shared<Block>("i", "looks_switchbackdropto");
-    addDropdownInput(block13, "BACKDROP", LooksBlocks::BACKDROP, "", createNullBlock("j"));
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 1);
 
-    compiler.init();
+    // 0
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, false));
+    vm->setBytecode(bytecode2);
+    vm->run();
 
-    // Test without any backdrops first
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropTo)).WillOnce(Return(4));
-    compiler.setBlock(block1);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 1);
 
-    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
+    stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndex)).WillOnce(Return(0));
-    compiler.setBlock(block1);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 1);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropTo)).WillOnce(Return(4));
-    compiler.setBlock(block2);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    // 1
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, false));
+    vm->setBytecode(bytecode3);
+    vm->run();
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropTo)).WillOnce(Return(4));
-    compiler.setBlock(block3);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 0);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropTo)).WillOnce(Return(4));
-    compiler.setBlock(block4);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    // 2
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, false));
+    stage.addCostume(std::make_shared<Costume>("2", "b3", "svg"));
+    stage.addCostume(std::make_shared<Costume>("test", "b4", "svg"));
+    stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropTo)).WillOnce(Return(4));
-    compiler.setBlock(block5);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    vm->setBytecode(bytecode4);
+    vm->run();
 
-    stage.addCostume(std::make_shared<Costume>("3", "b4", "svg"));
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 1);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndex)).WillOnce(Return(0));
-    compiler.setBlock(block6);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    // "2"
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, false));
+    stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::nextBackdrop)).WillOnce(Return(1));
-    compiler.setBlock(block7);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    vm->setBytecode(bytecode6);
+    vm->run();
 
-    stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 2);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndex)).WillOnce(Return(0));
-    compiler.setBlock(block8);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
+    // "3"
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, false));
+    stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::previousBackdrop)).WillOnce(Return(2));
-    compiler.setBlock(block9);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
-
-    stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndex)).WillOnce(Return(0));
-    compiler.setBlock(block10);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::randomBackdrop)).WillOnce(Return(3));
-    compiler.setBlock(block11);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
-
-    stage.addCostume(std::make_shared<Costume>("random backdrop", "b7", "svg"));
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndex)).WillOnce(Return(0));
-    compiler.setBlock(block12);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropTo)).WillOnce(Return(4));
-    compiler.setBlock(block13);
-    LooksBlocks::compileSwitchBackdropTo(&compiler);
-
-    compiler.end();
-
-    ASSERT_EQ(
-        compiler.bytecode(),
-        std::vector<unsigned int>(
-            { vm::OP_START,
-              vm::OP_CONST,
-              0,
-              vm::OP_EXEC,
-              4,
-              vm::OP_CONST,
-              1,
-              vm::OP_EXEC,
-              0,
-              vm::OP_CONST,
-              2,
-              vm::OP_EXEC,
-              4,
-              vm::OP_CONST,
-              3,
-              vm::OP_EXEC,
-              4,
-              vm::OP_CONST,
-              4,
-              vm::OP_EXEC,
-              4,
-              vm::OP_CONST,
-              5,
-              vm::OP_EXEC,
-              4,
-              vm::OP_CONST,
-              6,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              1,
-              vm::OP_CONST,
-              7,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              2,
-              vm::OP_CONST,
-              8,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              3,
-              vm::OP_CONST,
-              9,
-              vm::OP_EXEC,
-              0,
-              vm::OP_NULL,
-              vm::OP_EXEC,
-              4,
-              vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "backdrop2", 1, "0", "1", "2", "4", 3, 4, 5, 6 }));
-}
-
-TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
-{
-    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 unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_HALT };
-    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 1, vm::OP_HALT };
-    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 1, vm::OP_HALT };
-    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 1, vm::OP_HALT };
-    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::switchBackdropTo, &LooksBlocks::switchBackdropToByIndex };
-    static Value constValues[] = { "backdrop2", 0, 1, 2, 3, "next backdrop", "previous backdrop", -1, 0, 5, 6 };
-
-    Target target;
-
-    Stage stage;
-    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
-    stage.setCostumeIndex(0);
+    vm->setBytecode(bytecode7);
+    vm->run();
 
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setFunctions(functions);
-    vm.setConstValues(constValues);
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 2);
 
-    // "backdrop2"
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    vm.setBytecode(bytecode1);
-    vm.run();
+    // NaN
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, false));
+    stage.setCostumeIndex(2);
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 1);
+    vm->setBytecode(bytecode8);
+    vm->run();
 
-    // 0
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    vm.setBytecode(bytecode2);
-    vm.run();
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 0);
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 1);
+    // Infinity
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, false));
+    stage.setCostumeIndex(2);
 
-    stage.setCostumeIndex(0);
+    vm->setBytecode(bytecode9);
+    vm->run();
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    vm.reset();
-    vm.run();
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 0);
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 1);
+    // -Infinity
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, false));
+    stage.setCostumeIndex(2);
 
-    // 1
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    vm.setBytecode(bytecode3);
-    vm.run();
+    vm->setBytecode(bytecode10);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 0);
 
-    // 2
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    vm.setBytecode(bytecode4);
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 1);
+    // ""
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, false));
+    stage.setCostumeIndex(2);
 
-    // 3
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    vm.setBytecode(bytecode5);
-    vm.run();
+    vm->setBytecode(bytecode11);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 0);
-
-    stage.setCostumeIndex(1);
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 2);
 
-    // "2"
-    stage.addCostume(std::make_shared<Costume>("2", "b3", "svg"));
-    stage.addCostume(std::make_shared<Costume>("test", "b4", "svg"));
-    stage.setCostumeIndex(0);
+    // "   "
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, false));
+    stage.setCostumeIndex(2);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    vm.setBytecode(bytecode6);
-    vm.run();
+    vm->setBytecode(bytecode12);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 2);
 
     // "next backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
-    vm.setBytecode(bytecode7);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast(), &thread, false));
+    vm->setBytecode(bytecode13);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 3);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
 
     stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 4);
 
     // "previous backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
-    vm.setBytecode(bytecode8);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast(), &thread, false));
+    vm->setBytecode(bytecode14);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 3);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 2);
 
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 4);
 
     stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 5);
 
-    // -1 (index)
-    stage.setCostumeIndex(1);
+    // random backdrop
+    RandomGeneratorMock rng;
+    LooksBlocks::rng = &rng;
 
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    vm.setBytecode(bytecode9);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast(), &thread, false));
+    EXPECT_CALL(rng, randint(0, 5)).WillOnce(Return(3));
+    stage.setCostumeIndex(0);
+    vm->setBytecode(bytecode15);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 5);
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 3);
 
-    // 0 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    vm.setBytecode(bytecode10);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast(), &thread, false));
+    EXPECT_CALL(rng, randint(0, 5)).WillOnce(Return(5));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 5);
 
-    // 5 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    vm.setBytecode(bytecode11);
-    vm.run();
+    stage.addCostume(std::make_shared<Costume>("random backdrop", "b7", "svg"));
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 5);
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(6)->broadcast(), &thread, false));
+    EXPECT_CALL(rng, randint).Times(0);
+    vm->reset();
+    vm->run();
 
-    // 6 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    vm.setBytecode(bytecode12);
-    vm.run();
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 6);
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 0);
+    LooksBlocks::rng = RandomGenerator::instance().get();
 }
 
 TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 {
     Target target;
-    Stage stage;
     Compiler compiler(&m_engineMock, &target);
 
     // switch backdrop to (backdrop2) and wait
     auto block1 = std::make_shared<Block>("a", "looks_switchbackdroptoandwait");
     addDropdownInput(block1, "BACKDROP", LooksBlocks::BACKDROP, "backdrop2");
 
-    // switch backdrop to (0) and wait
-    auto block2 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
-    addDropdownInput(block2, "BACKDROP", LooksBlocks::BACKDROP, "0");
-
-    // switch backdrop to (1) and wait
-    auto block3 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
-    addDropdownInput(block3, "BACKDROP", LooksBlocks::BACKDROP, "1");
-
-    // switch backdrop to (2) and wait
-    auto block4 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
-    addDropdownInput(block4, "BACKDROP", LooksBlocks::BACKDROP, "2");
-
-    // switch backdrop to (4) and wait
-    auto block5 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
-    addDropdownInput(block5, "BACKDROP", LooksBlocks::BACKDROP, "4");
-
-    // switch backdrop to (3) and wait - there's a backdrop with this name
-    auto block6 = std::make_shared<Block>("c", "looks_switchbackdroptoandwait");
-    addDropdownInput(block6, "BACKDROP", LooksBlocks::BACKDROP, "3");
-
-    // switch backdrop to (next backdrop) and wait
-    auto block7 = std::make_shared<Block>("d", "looks_switchbackdroptoandwait");
-    addDropdownInput(block7, "BACKDROP", LooksBlocks::BACKDROP, "next backdrop");
-
-    // switch backdrop to (next backdrop) and wait - there's a backdrop with this name
-    auto block8 = std::make_shared<Block>("d", "looks_switchbackdroptoandwait");
-    addDropdownInput(block8, "BACKDROP", LooksBlocks::BACKDROP, "next backdrop");
-
-    // switch backdrop to (previous backdrop) and wait
-    auto block9 = std::make_shared<Block>("e", "looks_switchbackdroptoandwait");
-    addDropdownInput(block9, "BACKDROP", LooksBlocks::BACKDROP, "previous backdrop");
-
-    // switch backdrop to (previous backdrop) and wait - there's a backdrop with this name
-    auto block10 = std::make_shared<Block>("f", "looks_switchbackdroptoandwait");
-    addDropdownInput(block10, "BACKDROP", LooksBlocks::BACKDROP, "previous backdrop");
-
-    // switch backdrop to (random backdrop) and wait
-    auto block11 = std::make_shared<Block>("g", "looks_switchbackdroptoandwait");
-    addDropdownInput(block11, "BACKDROP", LooksBlocks::BACKDROP, "random backdrop");
-
-    // switch backdrop to (random backdrop) and wait - there's a backdrop with this name
-    auto block12 = std::make_shared<Block>("h", "looks_switchbackdroptoandwait");
-    addDropdownInput(block12, "BACKDROP", LooksBlocks::BACKDROP, "random backdrop");
-
     // switch backdrop to (null block) and wait
-    auto block13 = std::make_shared<Block>("i", "looks_switchbackdroptoandwait");
-    addDropdownInput(block13, "BACKDROP", LooksBlocks::BACKDROP, "", createNullBlock("j"));
+    auto block2 = std::make_shared<Block>("b", "looks_switchbackdroptoandwait");
+    addDropdownInput(block2, "BACKDROP", LooksBlocks::BACKDROP, "", createNullBlock("c"));
 
     compiler.init();
 
-    // Test without any backdrops first
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(4));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(0));
     compiler.setBlock(block1);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
-    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block1);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(4));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(0));
     compiler.setBlock(block2);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(4));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block3);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(4));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block4);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(4));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block5);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    stage.addCostume(std::make_shared<Costume>("3", "b4", "svg"));
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block6);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::nextBackdropAndWait)).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block7);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block8);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::previousBackdropAndWait)).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block9);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block10);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::randomBackdropAndWait)).WillOnce(Return(3));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block11);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    stage.addCostume(std::make_shared<Costume>("random backdrop", "b7", "svg"));
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block12);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(4));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
-    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
-    compiler.setBlock(block13);
-    LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
-
     compiler.end();
 
-    ASSERT_EQ(
-        compiler.bytecode(),
-        std::vector<unsigned int>(
-            { vm::OP_START,
-              vm::OP_CONST,
-              0,
-              vm::OP_EXEC,
-              4,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              1,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              2,
-              vm::OP_EXEC,
-              4,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              3,
-              vm::OP_EXEC,
-              4,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              4,
-              vm::OP_EXEC,
-              4,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              5,
-              vm::OP_EXEC,
-              4,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              6,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_EXEC,
-              1,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              7,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_EXEC,
-              2,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              8,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_EXEC,
-              3,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_CONST,
-              9,
-              vm::OP_EXEC,
-              0,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_NULL,
-              vm::OP_EXEC,
-              4,
-              vm::OP_EXEC,
-              6,
-              vm::OP_EXEC,
-              5,
-              vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "backdrop2", 1, "0", "1", "2", "4", 3, 4, 5, 6 }));
+    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(), std::vector<Value>({ "backdrop2" }));
 }
 
 TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 {
-    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::switchBackdropToAndWait, &LooksBlocks::switchBackdropToByIndexAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
-    static Value constValues[] = { "backdrop2", 0, 1, 2, 3, "next backdrop", "previous backdrop", -1, 0, 5, 6 };
+    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 unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 11, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode13[] = { vm::OP_START, vm::OP_CONST, 12, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode14[] = { vm::OP_START, vm::OP_CONST, 13, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode15[] = { vm::OP_START, vm::OP_CONST, 14, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::switchBackdropToAndWait };
+    static Value constValues[] = {
+        "backdrop2", 0, 1, 2, 3, "2", "3", SpecialValue::NaN, SpecialValue::Infinity, SpecialValue::NegativeInfinity, "", "   ", "next backdrop", "previous backdrop", "random backdrop"
+    };
 
     Target target;
 
@@ -2553,254 +2078,299 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
     stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
     stage.setCostumeIndex(0);
+    EXPECT_CALL(m_engineMock, stage()).WillRepeatedly(Return(&stage));
 
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setFunctions(functions);
-    vm.setConstValues(constValues);
+    Thread thread(&target, &m_engineMock, nullptr);
+    VirtualMachine *vm = thread.vm();
+    vm->setFunctions(functions);
+    vm->setConstValues(constValues);
 
     // "backdrop2"
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
-    vm.setBytecode(bytecode1);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, true));
+    vm->setBytecode(bytecode1);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
-    ASSERT_FALSE(vm.atEnd());
+    ASSERT_FALSE(vm->atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
-    vm.run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_TRUE(vm.atEnd());
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_TRUE(vm->atEnd());
 
     // 0
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
-    vm.setBytecode(bytecode2);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, true));
+    vm->setBytecode(bytecode2);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
-    ASSERT_FALSE(vm.atEnd());
+    ASSERT_FALSE(vm->atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
-    vm.run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_TRUE(vm.atEnd());
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_TRUE(vm->atEnd());
 
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, true));
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
-    ASSERT_TRUE(vm.atEnd());
+    ASSERT_TRUE(vm->atEnd());
 
     // 1
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
-    vm.setBytecode(bytecode3);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, true));
+    vm->setBytecode(bytecode3);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
+
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 0);
+    ASSERT_TRUE(vm->atEnd());
+
+    // 2
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, true));
+    stage.addCostume(std::make_shared<Costume>("2", "b3", "svg"));
+    stage.addCostume(std::make_shared<Costume>("test", "b4", "svg"));
+    stage.setCostumeIndex(0);
+
+    vm->setBytecode(bytecode4);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
+
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 1);
+
+    // "2"
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, true));
+    stage.setCostumeIndex(0);
+
+    vm->setBytecode(bytecode6);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
+
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 2);
+
+    // "3"
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, true));
+    stage.setCostumeIndex(0);
+
+    vm->setBytecode(bytecode7);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
+
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 2);
+
+    // NaN
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, true));
+    stage.setCostumeIndex(2);
+
+    vm->setBytecode(bytecode8);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
+
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 0);
+
+    // Infinity
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, true));
+    stage.setCostumeIndex(2);
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 0);
-    ASSERT_TRUE(vm.atEnd());
+    vm->setBytecode(bytecode9);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    // 2
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
-    vm.setBytecode(bytecode4);
-    vm.run();
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 0);
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 1);
+    // -Infinity
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, true));
+    stage.setCostumeIndex(2);
 
-    // 3
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
-    vm.setBytecode(bytecode5);
-    vm.run();
+    vm->setBytecode(bytecode10);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 0);
 
-    stage.setCostumeIndex(1);
+    // ""
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, true));
+    stage.setCostumeIndex(2);
 
-    // "2"
-    stage.addCostume(std::make_shared<Costume>("2", "b3", "svg"));
-    stage.addCostume(std::make_shared<Costume>("test", "b4", "svg"));
-    stage.setCostumeIndex(0);
+    vm->setBytecode(bytecode11);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
-    vm.setBytecode(bytecode6);
-    vm.run();
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 2);
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    // "   "
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, true));
+    stage.setCostumeIndex(2);
+
+    vm->setBytecode(bytecode12);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
+
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 2);
 
     // "next backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(true));
-    vm.setBytecode(bytecode7);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast(), &thread, true));
+    vm->resolvePromise();
+    vm->setBytecode(bytecode13);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 3);
-    ASSERT_FALSE(vm.atEnd());
+    ASSERT_FALSE(vm->atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(false));
-    vm.run();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_TRUE(vm.atEnd());
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_TRUE(vm->atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, true));
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, true));
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
 
     stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast(), &thread, true));
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 4);
 
     // "previous backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(true));
-    vm.setBytecode(bytecode8);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast(), &thread, true));
+    vm->resolvePromise();
+    vm->setBytecode(bytecode14);
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 3);
-    ASSERT_FALSE(vm.atEnd());
+    ASSERT_FALSE(vm->atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(false));
     stage.setCostumeIndex(2); // checkBackdropScripts() should still check index 3 even after changing the backdrop
-    vm.run();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
     stage.setCostumeIndex(3);
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_TRUE(vm.atEnd());
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_TRUE(vm->atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, true));
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 2);
 
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast(), &thread, true));
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 4);
 
     stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast(), &thread, true));
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 5);
 
-    // -1 (index)
-    stage.setCostumeIndex(1);
-
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(true));
-    vm.setBytecode(bytecode9);
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 1);
-    ASSERT_EQ(stage.costumeIndex(), 5);
-    ASSERT_FALSE(vm.atEnd());
+    // random backdrop
+    RandomGeneratorMock rng;
+    LooksBlocks::rng = &rng;
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast(), &thread, true));
+    EXPECT_CALL(rng, randint(0, 5)).WillOnce(Return(3));
+    stage.setCostumeIndex(0);
+    vm->resolvePromise();
+    vm->setBytecode(bytecode15);
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_TRUE(vm.atEnd());
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 3);
 
-    // 0 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
-    vm.setBytecode(bytecode10);
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast(), &thread, true));
+    EXPECT_CALL(rng, randint(0, 5)).WillOnce(Return(5));
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 0);
-    ASSERT_TRUE(vm.atEnd());
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 5);
 
-    // 5 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
-    vm.setBytecode(bytecode11);
-    vm.run();
+    stage.addCostume(std::make_shared<Costume>("random backdrop", "b7", "svg"));
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 5);
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(6)->broadcast(), &thread, true));
+    EXPECT_CALL(rng, randint).Times(0);
+    vm->reset();
+    vm->run();
+    vm->resolvePromise();
+    vm->run();
 
-    // 6 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
-    vm.setBytecode(bytecode12);
-    vm.run();
+    ASSERT_EQ(vm->registerCount(), 0);
+    ASSERT_EQ(stage.costumeIndex(), 6);
 
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 0);
+    LooksBlocks::rng = RandomGenerator::instance().get();
 }
 
 TEST_F(LooksBlocksTest, NextBackdrop)
@@ -2832,85 +2402,31 @@ TEST_F(LooksBlocksTest, NextBackdropImpl)
     stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
     stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
     stage.setCostumeIndex(0);
+    EXPECT_CALL(m_engineMock, stage()).WillRepeatedly(Return(&stage));
 
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setBytecode(bytecode);
-    vm.setFunctions(functions);
-
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 1);
-
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    vm.reset();
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 2);
-
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    vm.reset();
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 0);
-}
-
-TEST_F(LooksBlocksTest, NextBackdropAndWait)
-{
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::nextBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
-
-    Target target;
-
-    Stage stage;
-    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
-    stage.setCostumeIndex(0);
-
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setBytecode(bytecode);
-    vm.setFunctions(functions);
+    Thread thread(&target, &m_engineMock, nullptr);
+    VirtualMachine *vm = thread.vm();
+    vm->setBytecode(bytecode);
+    vm->setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, false));
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
-    ASSERT_FALSE(vm.atEnd());
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 2);
-    ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 0);
 }
 
@@ -2926,85 +2442,31 @@ TEST_F(LooksBlocksTest, PreviousBackdrop)
     stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
     stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
     stage.setCostumeIndex(2);
+    EXPECT_CALL(m_engineMock, stage()).WillRepeatedly(Return(&stage));
 
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setBytecode(bytecode);
-    vm.setFunctions(functions);
-
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 1);
-
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    vm.reset();
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 0);
-
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    vm.reset();
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 2);
-}
-
-TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
-{
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::previousBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
-
-    Target target;
-
-    Stage stage;
-    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
-    stage.setCostumeIndex(2);
-
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setBytecode(bytecode);
-    vm.setFunctions(functions);
+    Thread thread(&target, &m_engineMock, nullptr);
+    VirtualMachine *vm = thread.vm();
+    vm->setBytecode(bytecode);
+    vm->setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, false));
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
-    ASSERT_FALSE(vm.atEnd());
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 0);
-    ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 2);
 }
 
@@ -3016,104 +2478,42 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
     Target target;
 
     Stage stage;
+    EXPECT_CALL(m_engineMock, stage()).WillRepeatedly(Return(&stage));
 
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setBytecode(bytecode);
-    vm.setFunctions(functions);
-
-    RandomGeneratorMock rng;
-    LooksBlocks::rng = &rng;
-
-    EXPECT_CALL(rng, randint).Times(0);
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-
-    stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
-    stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
-
-    EXPECT_CALL(rng, randint(0, 2)).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    vm.reset();
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 1);
-
-    stage.addCostume(std::make_shared<Costume>("backdrop4", "b4", "svg"));
-
-    EXPECT_CALL(rng, randint(0, 3)).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    vm.reset();
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_EQ(stage.costumeIndex(), 2);
-
-    LooksBlocks::rng = RandomGenerator::instance().get();
-}
-
-TEST_F(LooksBlocksTest, RandomBackdropAndWait)
-{
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::randomBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
-
-    Target target;
-
-    Stage stage;
-
-    VirtualMachine vm(&target, &m_engineMock, nullptr);
-    vm.setBytecode(bytecode);
-    vm.setFunctions(functions);
+    Thread thread(&target, &m_engineMock, nullptr);
+    VirtualMachine *vm = thread.vm();
+    vm->setBytecode(bytecode);
+    vm->setFunctions(functions);
 
     RandomGeneratorMock rng;
     LooksBlocks::rng = &rng;
 
     EXPECT_CALL(rng, randint).Times(0);
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning).Times(0);
-    vm.run();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
 
     stage.addCostume(std::make_shared<Costume>("backdrop1", "b1", "svg"));
     stage.addCostume(std::make_shared<Costume>("backdrop2", "b2", "svg"));
     stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
 
     EXPECT_CALL(rng, randint(0, 2)).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
-    ASSERT_FALSE(vm.atEnd());
-
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
-    vm.run();
-
-    ASSERT_EQ(vm.registerCount(), 0);
-    ASSERT_TRUE(vm.atEnd());
 
     stage.addCostume(std::make_shared<Costume>("backdrop4", "b4", "svg"));
 
     EXPECT_CALL(rng, randint(0, 3)).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
-    vm.reset();
-    vm.run();
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast(), &thread, false));
+    vm->reset();
+    vm->run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm->registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 2);
-    ASSERT_TRUE(vm.atEnd());
 
     LooksBlocks::rng = RandomGenerator::instance().get();
 }
@@ -3157,13 +2557,13 @@ TEST_F(LooksBlocksTest, GoToFrontBackImpl)
     VirtualMachine vm(&sprite, &m_engineMock, nullptr);
     vm.setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, moveSpriteToFront(&sprite));
+    EXPECT_CALL(m_engineMock, moveDrawableToFront(&sprite));
     vm.setBytecode(bytecode1);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(m_engineMock, moveSpriteToBack(&sprite));
+    EXPECT_CALL(m_engineMock, moveDrawableToBack(&sprite));
     vm.reset();
     vm.setBytecode(bytecode2);
     vm.run();
@@ -3214,13 +2614,13 @@ TEST_F(LooksBlocksTest, GoForwardBackwardLayersImpl)
     vm.setFunctions(functions);
     vm.setConstValues(constValues);
 
-    EXPECT_CALL(m_engineMock, moveSpriteForwardLayers(&sprite, 5));
+    EXPECT_CALL(m_engineMock, moveDrawableForwardLayers(&sprite, 5));
     vm.setBytecode(bytecode1);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(m_engineMock, moveSpriteBackwardLayers(&sprite, 3));
+    EXPECT_CALL(m_engineMock, moveDrawableBackwardLayers(&sprite, 3));
     vm.reset();
     vm.setBytecode(bytecode2);
     vm.run();
diff --git a/test/blocks/motion_blocks_test.cpp b/test/blocks/motion_blocks_test.cpp
index 4a2853ca..4f381061 100644
--- a/test/blocks/motion_blocks_test.cpp
+++ b/test/blocks/motion_blocks_test.cpp
@@ -26,8 +26,8 @@ class MotionBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<MotionBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<MotionBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         // For any motion block
@@ -88,69 +88,64 @@ class MotionBlocksTest : public testing::Test
             block->addField(field);
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
 };
 
 TEST_F(MotionBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Motion");
-}
-
-TEST_F(MotionBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Motion");
 }
 
 TEST_F(MotionBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_movesteps", &MotionBlocks::compileMoveSteps));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_turnright", &MotionBlocks::compileTurnRight));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_turnleft", &MotionBlocks::compileTurnLeft));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_pointindirection", &MotionBlocks::compilePointInDirection));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_pointtowards", &MotionBlocks::compilePointTowards));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_gotoxy", &MotionBlocks::compileGoToXY));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_goto", &MotionBlocks::compileGoTo));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_glidesecstoxy", &MotionBlocks::compileGlideSecsToXY));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_glideto", &MotionBlocks::compileGlideTo));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_changexby", &MotionBlocks::compileChangeXBy));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_setx", &MotionBlocks::compileSetX));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_changeyby", &MotionBlocks::compileChangeYBy));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_sety", &MotionBlocks::compileSetY));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_ifonedgebounce", &MotionBlocks::compileIfOnEdgeBounce));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_setrotationstyle", &MotionBlocks::compileSetRotationStyle));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_xposition", &MotionBlocks::compileXPosition));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_yposition", &MotionBlocks::compileYPosition));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "motion_direction", &MotionBlocks::compileDirection));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_movesteps", &MotionBlocks::compileMoveSteps));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_turnright", &MotionBlocks::compileTurnRight));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_turnleft", &MotionBlocks::compileTurnLeft));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_pointindirection", &MotionBlocks::compilePointInDirection));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_pointtowards", &MotionBlocks::compilePointTowards));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_gotoxy", &MotionBlocks::compileGoToXY));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_goto", &MotionBlocks::compileGoTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_glidesecstoxy", &MotionBlocks::compileGlideSecsToXY));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_glideto", &MotionBlocks::compileGlideTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_changexby", &MotionBlocks::compileChangeXBy));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_setx", &MotionBlocks::compileSetX));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_changeyby", &MotionBlocks::compileChangeYBy));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_sety", &MotionBlocks::compileSetY));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_ifonedgebounce", &MotionBlocks::compileIfOnEdgeBounce));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_setrotationstyle", &MotionBlocks::compileSetRotationStyle));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_xposition", &MotionBlocks::compileXPosition));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_yposition", &MotionBlocks::compileYPosition));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "motion_direction", &MotionBlocks::compileDirection));
 
     // Monitor names
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "motion_xposition", &MotionBlocks::xPositionMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "motion_yposition", &MotionBlocks::yPositionMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "motion_direction", &MotionBlocks::directionMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "motion_xposition", &MotionBlocks::xPositionMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "motion_yposition", &MotionBlocks::yPositionMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "motion_direction", &MotionBlocks::directionMonitorName));
 
     // Inputs
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STEPS", MotionBlocks::STEPS));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DEGREES", MotionBlocks::DEGREES));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DIRECTION", MotionBlocks::DIRECTION));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TOWARDS", MotionBlocks::TOWARDS));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "X", MotionBlocks::X));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "Y", MotionBlocks::Y));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TO", MotionBlocks::TO));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "SECS", MotionBlocks::SECS));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DX", MotionBlocks::DX));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DY", MotionBlocks::DY));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "STEPS", MotionBlocks::STEPS));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "DEGREES", MotionBlocks::DEGREES));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "DIRECTION", MotionBlocks::DIRECTION));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "TOWARDS", MotionBlocks::TOWARDS));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "X", MotionBlocks::X));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "Y", MotionBlocks::Y));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "TO", MotionBlocks::TO));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "SECS", MotionBlocks::SECS));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "DX", MotionBlocks::DX));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "DY", MotionBlocks::DY));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "STYLE", MotionBlocks::STYLE));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "STYLE", MotionBlocks::STYLE));
 
     // Field values
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "left-right", MotionBlocks::LeftRight));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "don't rotate", MotionBlocks::DoNotRotate));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "all around", MotionBlocks::AllAround));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "left-right", MotionBlocks::LeftRight));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "don't rotate", MotionBlocks::DoNotRotate));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "all around", MotionBlocks::AllAround));
 
-    m_section->registerBlocks(&m_engineMock);
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(MotionBlocksTest, MoveSteps)
diff --git a/test/blocks/operator_blocks_test.cpp b/test/blocks/operator_blocks_test.cpp
index cb5a465e..d902c700 100644
--- a/test/blocks/operator_blocks_test.cpp
+++ b/test/blocks/operator_blocks_test.cpp
@@ -17,8 +17,8 @@ class OperatorBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<OperatorBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<OperatorBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         // For any operator block
@@ -56,77 +56,72 @@ class OperatorBlocksTest : public testing::Test
             block->addField(field);
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
 };
 
 TEST_F(OperatorBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Operators");
-}
-
-TEST_F(OperatorBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Operators");
 }
 
 TEST_F(OperatorBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_add", &OperatorBlocks::compileAdd)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_subtract", &OperatorBlocks::compileSubtract)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_multiply", &OperatorBlocks::compileMultiply)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_divide", &OperatorBlocks::compileDivide)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_random", &OperatorBlocks::compilePickRandom)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_lt", &OperatorBlocks::compileLessThan)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_equals", &OperatorBlocks::compileEquals)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_gt", &OperatorBlocks::compileGreaterThan)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_and", &OperatorBlocks::compileAnd)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_or", &OperatorBlocks::compileOr)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_not", &OperatorBlocks::compileNot)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_join", &OperatorBlocks::compileJoin)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_letter_of", &OperatorBlocks::compileLetterOf)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_length", &OperatorBlocks::compileLength)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_contains", &OperatorBlocks::compileContains)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_mod", &OperatorBlocks::compileMod)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_round", &OperatorBlocks::compileRound)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "operator_mathop", &OperatorBlocks::compileMathOp)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_add", &OperatorBlocks::compileAdd)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_subtract", &OperatorBlocks::compileSubtract)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_multiply", &OperatorBlocks::compileMultiply)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_divide", &OperatorBlocks::compileDivide)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_random", &OperatorBlocks::compilePickRandom)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_lt", &OperatorBlocks::compileLessThan)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_equals", &OperatorBlocks::compileEquals)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_gt", &OperatorBlocks::compileGreaterThan)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_and", &OperatorBlocks::compileAnd)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_or", &OperatorBlocks::compileOr)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_not", &OperatorBlocks::compileNot)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_join", &OperatorBlocks::compileJoin)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_letter_of", &OperatorBlocks::compileLetterOf)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_length", &OperatorBlocks::compileLength)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_contains", &OperatorBlocks::compileContains)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_mod", &OperatorBlocks::compileMod)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_round", &OperatorBlocks::compileRound)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "operator_mathop", &OperatorBlocks::compileMathOp)).Times(1);
 
     // Inputs
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "NUM1", OperatorBlocks::NUM1)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "NUM2", OperatorBlocks::NUM2)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "FROM", OperatorBlocks::FROM)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TO", OperatorBlocks::TO)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "OPERAND1", OperatorBlocks::OPERAND1)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "OPERAND2", OperatorBlocks::OPERAND2)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "OPERAND", OperatorBlocks::OPERAND)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STRING1", OperatorBlocks::STRING1)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STRING2", OperatorBlocks::STRING2)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "LETTER", OperatorBlocks::LETTER)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "STRING", OperatorBlocks::STRING)).Times(1);
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "NUM", OperatorBlocks::NUM)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "NUM1", OperatorBlocks::NUM1)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "NUM2", OperatorBlocks::NUM2)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "FROM", OperatorBlocks::FROM)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "TO", OperatorBlocks::TO)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "OPERAND1", OperatorBlocks::OPERAND1)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "OPERAND2", OperatorBlocks::OPERAND2)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "OPERAND", OperatorBlocks::OPERAND)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "STRING1", OperatorBlocks::STRING1)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "STRING2", OperatorBlocks::STRING2)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "LETTER", OperatorBlocks::LETTER)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "STRING", OperatorBlocks::STRING)).Times(1);
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "NUM", OperatorBlocks::NUM)).Times(1);
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "OPERATOR", OperatorBlocks::OPERATOR));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "OPERATOR", OperatorBlocks::OPERATOR));
 
     // Field values
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "abs", OperatorBlocks::Abs)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "floor", OperatorBlocks::Floor)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "ceiling", OperatorBlocks::Ceiling)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "sqrt", OperatorBlocks::Sqrt)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "sin", OperatorBlocks::Sin)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "cos", OperatorBlocks::Cos)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "tan", OperatorBlocks::Tan)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "asin", OperatorBlocks::Asin)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "acos", OperatorBlocks::Acos)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "atan", OperatorBlocks::Atan)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "ln", OperatorBlocks::Ln)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "log", OperatorBlocks::Log)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "e ^", OperatorBlocks::Eexp)).Times(1);
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "10 ^", OperatorBlocks::Op_10exp)).Times(1);
-
-    m_section->registerBlocks(&m_engineMock);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "abs", OperatorBlocks::Abs)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "floor", OperatorBlocks::Floor)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "ceiling", OperatorBlocks::Ceiling)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "sqrt", OperatorBlocks::Sqrt)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "sin", OperatorBlocks::Sin)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "cos", OperatorBlocks::Cos)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "tan", OperatorBlocks::Tan)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "asin", OperatorBlocks::Asin)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "acos", OperatorBlocks::Acos)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "atan", OperatorBlocks::Atan)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "ln", OperatorBlocks::Ln)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "log", OperatorBlocks::Log)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "e ^", OperatorBlocks::Eexp)).Times(1);
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "10 ^", OperatorBlocks::Op_10exp)).Times(1);
+
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(OperatorBlocksTest, Add)
@@ -837,7 +832,7 @@ TEST_F(OperatorBlocksTest, MathOpLn)
         vm::OP_HALT
     };
     static BlockFunc functions[] = { &OperatorBlocks::op_ln };
-    static Value constValues[] = { Value::SpecialValue::NegativeInfinity, -2.5, 0, Value::SpecialValue::NaN, std::exp(1), 50, Value::SpecialValue::Infinity };
+    static Value constValues[] = { SpecialValue::NegativeInfinity, -2.5, 0, SpecialValue::NaN, std::exp(1), 50, SpecialValue::Infinity };
 
     VirtualMachine vm;
     vm.setBytecode(bytecode);
@@ -890,7 +885,7 @@ TEST_F(OperatorBlocksTest, MathOpLog)
         vm::OP_HALT
     };
     static BlockFunc functions[] = { &OperatorBlocks::op_log };
-    static Value constValues[] = { Value::SpecialValue::NegativeInfinity, -2.5, 0, Value::SpecialValue::NaN, 100, 1500, Value::SpecialValue::Infinity };
+    static Value constValues[] = { SpecialValue::NegativeInfinity, -2.5, 0, SpecialValue::NaN, 100, 1500, SpecialValue::Infinity };
 
     VirtualMachine vm;
     vm.setBytecode(bytecode);
@@ -943,7 +938,7 @@ TEST_F(OperatorBlocksTest, MathOpExp)
         vm::OP_HALT
     };
     static BlockFunc functions[] = { &OperatorBlocks::op_eexp };
-    static Value constValues[] = { Value::SpecialValue::NegativeInfinity, -3.25, 0, Value::SpecialValue::NaN, 1, 5, Value::SpecialValue::Infinity };
+    static Value constValues[] = { SpecialValue::NegativeInfinity, -3.25, 0, SpecialValue::NaN, 1, 5, SpecialValue::Infinity };
 
     VirtualMachine vm;
     vm.setBytecode(bytecode);
@@ -996,7 +991,7 @@ TEST_F(OperatorBlocksTest, MathOp10Exp)
         vm::OP_HALT
     };
     static BlockFunc functions[] = { &OperatorBlocks::op_10exp };
-    static Value constValues[] = { Value::SpecialValue::NegativeInfinity, -2, 0, Value::SpecialValue::NaN, 1, 5.5, Value::SpecialValue::Infinity };
+    static Value constValues[] = { SpecialValue::NegativeInfinity, -2, 0, SpecialValue::NaN, 1, 5.5, SpecialValue::Infinity };
 
     VirtualMachine vm;
     vm.setBytecode(bytecode);
diff --git a/test/blocks/sensing_blocks_test.cpp b/test/blocks/sensing_blocks_test.cpp
index ecc61337..ecb5588c 100644
--- a/test/blocks/sensing_blocks_test.cpp
+++ b/test/blocks/sensing_blocks_test.cpp
@@ -4,6 +4,7 @@
 #include <scratchcpp/field.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
+#include <scratchcpp/textbubble.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/variable.h>
 #include <enginemock.h>
@@ -30,8 +31,8 @@ class SensingBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<SensingBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<SensingBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         std::shared_ptr<Block> createSensingCurrentBlock(const std::string &id, const std::string &optionStr, SensingBlocks::FieldValues option)
@@ -100,7 +101,7 @@ class SensingBlocksTest : public testing::Test
             block->addField(field);
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
         TimerMock m_timerMock;
@@ -114,83 +115,80 @@ struct QuestionSpy
 
 TEST_F(SensingBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Sensing");
-}
-
-TEST_F(SensingBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Sensing");
 }
 
 TEST_F(SensingBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_touchingobject", &SensingBlocks::compileTouchingObject));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_touchingcolor", &SensingBlocks::compileTouchingColor));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_distanceto", &SensingBlocks::compileDistanceTo));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_askandwait", &SensingBlocks::compileAskAndWait));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_answer", &SensingBlocks::compileAnswer));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_keypressed", &SensingBlocks::compileKeyPressed));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_mousedown", &SensingBlocks::compileMouseDown));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_mousex", &SensingBlocks::compileMouseX));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_mousey", &SensingBlocks::compileMouseY));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_setdragmode", &SensingBlocks::compileSetDragMode));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_loudness", &SensingBlocks::compileLoudness));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_loud", &SensingBlocks::compileLoud));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_timer", &SensingBlocks::compileTimer));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_resettimer", &SensingBlocks::compileResetTimer));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_of", &SensingBlocks::compileOf));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_current", &SensingBlocks::compileCurrent));
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_dayssince2000", &SensingBlocks::compileDaysSince2000));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_touchingobject", &SensingBlocks::compileTouchingObject));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_touchingcolor", &SensingBlocks::compileTouchingColor));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_coloristouchingcolor", &SensingBlocks::compileColorIsTouchingColor));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_distanceto", &SensingBlocks::compileDistanceTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_askandwait", &SensingBlocks::compileAskAndWait));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_answer", &SensingBlocks::compileAnswer));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_keypressed", &SensingBlocks::compileKeyPressed));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_mousedown", &SensingBlocks::compileMouseDown));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_mousex", &SensingBlocks::compileMouseX));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_mousey", &SensingBlocks::compileMouseY));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_setdragmode", &SensingBlocks::compileSetDragMode));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_loudness", &SensingBlocks::compileLoudness));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_loud", &SensingBlocks::compileLoud));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_timer", &SensingBlocks::compileTimer));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_resettimer", &SensingBlocks::compileResetTimer));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_of", &SensingBlocks::compileOf));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_current", &SensingBlocks::compileCurrent));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sensing_dayssince2000", &SensingBlocks::compileDaysSince2000));
 
     // Monitor names
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_mousedown", &SensingBlocks::mouseDownMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_mousex", &SensingBlocks::mouseXMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_mousey", &SensingBlocks::mouseYMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_loudness", &SensingBlocks::loudnessMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_timer", &SensingBlocks::timerMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_current", &SensingBlocks::currentMonitorName));
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_dayssince2000", &SensingBlocks::daysSince2000MonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "sensing_mousedown", &SensingBlocks::mouseDownMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "sensing_mousex", &SensingBlocks::mouseXMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "sensing_mousey", &SensingBlocks::mouseYMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "sensing_loudness", &SensingBlocks::loudnessMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "sensing_timer", &SensingBlocks::timerMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "sensing_current", &SensingBlocks::currentMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "sensing_dayssince2000", &SensingBlocks::daysSince2000MonitorName));
 
     // Inputs
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "TOUCHINGOBJECTMENU", SensingBlocks::TOUCHINGOBJECTMENU));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "COLOR", SensingBlocks::COLOR));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "DISTANCETOMENU", SensingBlocks::DISTANCETOMENU));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "QUESTION", SensingBlocks::QUESTION));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "KEY_OPTION", SensingBlocks::KEY_OPTION));
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "OBJECT", SensingBlocks::OBJECT));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "TOUCHINGOBJECTMENU", SensingBlocks::TOUCHINGOBJECTMENU));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "COLOR", SensingBlocks::COLOR));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "COLOR2", SensingBlocks::COLOR2));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "DISTANCETOMENU", SensingBlocks::DISTANCETOMENU));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "QUESTION", SensingBlocks::QUESTION));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "KEY_OPTION", SensingBlocks::KEY_OPTION));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "OBJECT", SensingBlocks::OBJECT));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "CURRENTMENU", SensingBlocks::CURRENTMENU));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "DRAG_MODE", SensingBlocks::DRAG_MODE));
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "PROPERTY", SensingBlocks::PROPERTY));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "CURRENTMENU", SensingBlocks::CURRENTMENU));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "DRAG_MODE", SensingBlocks::DRAG_MODE));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "PROPERTY", SensingBlocks::PROPERTY));
 
     // Field values
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "YEAR", SensingBlocks::YEAR));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "MONTH", SensingBlocks::MONTH));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "DATE", SensingBlocks::DATE));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "DAYOFWEEK", SensingBlocks::DAYOFWEEK));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "HOUR", SensingBlocks::HOUR));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "MINUTE", SensingBlocks::MINUTE));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "SECOND", SensingBlocks::SECOND));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "draggable", SensingBlocks::Draggable));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "not draggable", SensingBlocks::NotDraggable));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "x position", SensingBlocks::XPosition));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "y position", SensingBlocks::YPosition));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "direction", SensingBlocks::Direction));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "costume #", SensingBlocks::CostumeNumber));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "costume name", SensingBlocks::CostumeName));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "size", SensingBlocks::Size));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "volume", SensingBlocks::Volume));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "background #", SensingBlocks::BackdropNumber));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "backdrop #", SensingBlocks::BackdropNumber));
-    EXPECT_CALL(m_engineMock, addFieldValue(m_section.get(), "backdrop name", SensingBlocks::BackdropName));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "YEAR", SensingBlocks::YEAR));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "MONTH", SensingBlocks::MONTH));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "DATE", SensingBlocks::DATE));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "DAYOFWEEK", SensingBlocks::DAYOFWEEK));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "HOUR", SensingBlocks::HOUR));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "MINUTE", SensingBlocks::MINUTE));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "SECOND", SensingBlocks::SECOND));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "draggable", SensingBlocks::Draggable));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "not draggable", SensingBlocks::NotDraggable));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "x position", SensingBlocks::XPosition));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "y position", SensingBlocks::YPosition));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "direction", SensingBlocks::Direction));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "costume #", SensingBlocks::CostumeNumber));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "costume name", SensingBlocks::CostumeName));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "size", SensingBlocks::Size));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "volume", SensingBlocks::Volume));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "background #", SensingBlocks::BackdropNumber));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "backdrop #", SensingBlocks::BackdropNumber));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "backdrop name", SensingBlocks::BackdropName));
 
     // Callbacks
     sigslot::signal<const std::string &> questionAnswered;
     EXPECT_CALL(m_engineMock, questionAnswered()).WillOnce(ReturnRef(questionAnswered));
 
-    m_section->registerBlocks(&m_engineMock);
+    m_extension->registerBlocks(&m_engineMock);
 
     ASSERT_EQ(questionAnswered.slot_count(), 1);
     ASSERT_EQ(questionAnswered.disconnect(&SensingBlocks::onAnswer), 1);
@@ -454,6 +452,79 @@ TEST_F(SensingBlocksTest, TouchingColorImpl)
     ASSERT_TRUE(vm.getInput(0, 1)->toBool());
 }
 
+TEST_F(SensingBlocksTest, ColorIsTouchingColor)
+{
+    Compiler compiler(&m_engineMock);
+
+    // color (#FF00FF) is touching color (#FFFF00)
+    auto block1 = std::make_shared<Block>("a", "sensing_coloristouchingcolor");
+    addValueInput(block1, "COLOR", SensingBlocks::COLOR, "#FF00FF");
+    addValueInput(block1, "COLOR2", SensingBlocks::COLOR2, "#FFFF00");
+
+    // color (null block) is touching color (null block)
+    auto block2 = std::make_shared<Block>("b", "sensing_coloristouchingcolor");
+    addDropdownInput(block2, "COLOR", SensingBlocks::COLOR, "", createNullBlock("c"));
+    addDropdownInput(block2, "COLOR2", SensingBlocks::COLOR2, "", createNullBlock("d"));
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::colorIsTouchingColor)).WillOnce(Return(1));
+    compiler.setBlock(block1);
+    SensingBlocks::compileColorIsTouchingColor(&compiler);
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::colorIsTouchingColor)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    SensingBlocks::compileColorIsTouchingColor(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_NULL, vm::OP_NULL, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "#FFFF00", "#FF00FF" }));
+}
+
+TEST_F(SensingBlocksTest, ColorIsTouchingColorImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SensingBlocks::colorIsTouchingColor };
+    static Value constValues[] = { "#FF00FF", "#FFFF00", 1946195606, 238 };
+
+    TargetMock target;
+    Sprite sprite;
+    VirtualMachine vm(&target, nullptr, nullptr);
+    vm.setFunctions(functions);
+    vm.setConstValues(constValues);
+
+    EXPECT_CALL(target, touchingColor(constValues[0], constValues[1])).WillOnce(Return(false));
+    vm.setBytecode(bytecode1);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(target, touchingColor(constValues[0], constValues[1])).WillOnce(Return(true));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(target, touchingColor(constValues[2], constValues[3])).WillOnce(Return(false));
+    vm.reset();
+    vm.setBytecode(bytecode2);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_FALSE(vm.getInput(0, 1)->toBool());
+
+    EXPECT_CALL(target, touchingColor(constValues[2], constValues[3])).WillOnce(Return(true));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_TRUE(vm.getInput(0, 1)->toBool());
+}
+
 TEST_F(SensingBlocksTest, DistanceTo)
 {
     Compiler compiler(&m_engineMock);
@@ -642,7 +713,7 @@ TEST_F(SensingBlocksTest, AskAndWaitAndAnswerImpl)
     static Value constValues[] = { "test1", "test2", "test3" };
 
     Sprite sprite;
-    sprite.setBubbleType(Target::BubbleType::Think);
+    sprite.bubble()->setType(TextBubble::Type::Think);
     Stage stage;
     QuestionSpy spy;
     auto asked = std::bind(&QuestionSpy::asked, &spy, std::placeholders::_1);
@@ -662,8 +733,8 @@ TEST_F(SensingBlocksTest, AskAndWaitAndAnswerImpl)
 
     ASSERT_EQ(vm1.registerCount(), 0);
     ASSERT_FALSE(vm1.atEnd());
-    ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(sprite.bubbleText(), "test1");
+    ASSERT_EQ(sprite.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(sprite.bubble()->text(), "test1");
 
     EXPECT_CALL(m_engineMock, questionAsked).Times(0);
     vm1.reset();
@@ -672,8 +743,8 @@ TEST_F(SensingBlocksTest, AskAndWaitAndAnswerImpl)
 
     ASSERT_EQ(vm1.registerCount(), 0);
     ASSERT_FALSE(vm1.atEnd());
-    ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(sprite.bubbleText(), "test1");
+    ASSERT_EQ(sprite.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(sprite.bubble()->text(), "test1");
 
     EXPECT_CALL(m_engineMock, questionAsked).Times(0);
     sprite.setVisible(false);
@@ -684,8 +755,8 @@ TEST_F(SensingBlocksTest, AskAndWaitAndAnswerImpl)
 
     ASSERT_EQ(vm1.registerCount(), 0);
     ASSERT_FALSE(vm1.atEnd());
-    ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(sprite.bubbleText(), "test1");
+    ASSERT_EQ(sprite.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(sprite.bubble()->text(), "test1");
 
     // Ask a question from the stage
     VirtualMachine vm2(&stage, &m_engineMock, nullptr);
@@ -697,15 +768,15 @@ TEST_F(SensingBlocksTest, AskAndWaitAndAnswerImpl)
     vm2.run();
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_FALSE(vm2.atEnd());
-    ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(sprite.bubbleText(), "test1");
+    ASSERT_EQ(sprite.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(sprite.bubble()->text(), "test1");
 
     // Answer the questions
     EXPECT_CALL(m_engineMock, questionAsked()).WillOnce(ReturnRef(askedSignal));
     EXPECT_CALL(spy, asked(""));
     SensingBlocks::onAnswer("hi");
-    ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Say);
-    ASSERT_EQ(sprite.bubbleText(), "test2");
+    ASSERT_EQ(sprite.bubble()->type(), TextBubble::Type::Say);
+    ASSERT_EQ(sprite.bubble()->text(), "test2");
 
     vm1.reset();
     vm1.setBytecode(bytecode4);
@@ -716,7 +787,7 @@ TEST_F(SensingBlocksTest, AskAndWaitAndAnswerImpl)
     EXPECT_CALL(m_engineMock, questionAsked()).WillOnce(ReturnRef(askedSignal));
     EXPECT_CALL(spy, asked("test3"));
     SensingBlocks::onAnswer("hello");
-    ASSERT_TRUE(sprite.bubbleText().empty());
+    ASSERT_TRUE(sprite.bubble()->text().empty());
 
     vm1.reset();
     vm1.run();
@@ -726,8 +797,8 @@ TEST_F(SensingBlocksTest, AskAndWaitAndAnswerImpl)
     EXPECT_CALL(m_engineMock, questionAsked()).WillOnce(ReturnRef(askedSignal));
     EXPECT_CALL(spy, asked("test2"));
     SensingBlocks::onAnswer("world");
-    ASSERT_TRUE(sprite.bubbleText().empty());
-    ASSERT_TRUE(stage.bubbleText().empty());
+    ASSERT_TRUE(sprite.bubble()->text().empty());
+    ASSERT_TRUE(stage.bubble()->text().empty());
 
     vm1.reset();
     vm1.run();
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
index 96992550..0d25c820 100644
--- a/test/blocks/sound_blocks_test.cpp
+++ b/test/blocks/sound_blocks_test.cpp
@@ -22,8 +22,8 @@ class SoundBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<SoundBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<SoundBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         std::shared_ptr<Block> createNullBlock(const std::string &id)
@@ -81,50 +81,45 @@ class SoundBlocksTest : public testing::Test
             block->addField(field);
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         Engine m_engine;
         EngineMock m_engineMock;
 };
 
 TEST_F(SoundBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Sound");
-}
-
-TEST_F(SoundBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Sound");
 }
 
 TEST_F(SoundBlocksTest, RegisterBlocks)
 {
     // Blocks
-    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));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_play", &SoundBlocks::compilePlay));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_playuntildone", &SoundBlocks::compilePlayUntilDone));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_stopallsounds", &SoundBlocks::compileStopAllSounds));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_seteffectto", &SoundBlocks::compileSetEffectTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_changeeffectby", &SoundBlocks::compileChangeEffectBy));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_changevolumeby", &SoundBlocks::compileChangeVolumeBy));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_cleareffects", &SoundBlocks::compileClearEffects));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_setvolumeto", &SoundBlocks::compileSetVolumeTo));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "sound_volume", &SoundBlocks::compileVolume));
 
     // Monitor names
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sound_volume", &SoundBlocks::volumeMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "sound_volume", &SoundBlocks::volumeMonitorName));
 
     // 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));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "SOUND_MENU", SoundBlocks::SOUND_MENU));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "VALUE", SoundBlocks::VALUE));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "VOLUME", SoundBlocks::VOLUME));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "EFFECT", SoundBlocks::EFFECT));
+    EXPECT_CALL(m_engineMock, addField(m_extension.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));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "PITCH", SoundBlocks::PITCH));
+    EXPECT_CALL(m_engineMock, addFieldValue(m_extension.get(), "PAN", SoundBlocks::PAN));
 
-    m_section->registerBlocks(&m_engineMock);
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(SoundBlocksTest, Play)
diff --git a/test/blocks/variable_blocks_test.cpp b/test/blocks/variable_blocks_test.cpp
index 079397ff..8d50aefd 100644
--- a/test/blocks/variable_blocks_test.cpp
+++ b/test/blocks/variable_blocks_test.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/variable.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/monitor.h>
 #include <enginemock.h>
@@ -20,8 +21,8 @@ class VariableBlocksTest : public testing::Test
     public:
         void SetUp() override
         {
-            m_section = std::make_unique<VariableBlocks>();
-            m_section->registerBlocks(&m_engine);
+            m_extension = std::make_unique<VariableBlocks>();
+            m_extension->registerBlocks(&m_engine);
         }
 
         // For set variable to and change variable by
@@ -53,43 +54,38 @@ class VariableBlocksTest : public testing::Test
             return block;
         }
 
-        std::unique_ptr<IBlockSection> m_section;
+        std::unique_ptr<IExtension> m_extension;
         EngineMock m_engineMock;
         Engine m_engine;
 };
 
 TEST_F(VariableBlocksTest, Name)
 {
-    ASSERT_EQ(m_section->name(), "Variables");
-}
-
-TEST_F(VariableBlocksTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
+    ASSERT_EQ(m_extension->name(), "Variables");
 }
 
 TEST_F(VariableBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_variable", &VariableBlocks::compileVariable)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_setvariableto", &VariableBlocks::compileSetVariable)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_changevariableby", &VariableBlocks::compileChangeVariableBy)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_showvariable", &VariableBlocks::compileShowVariable)).Times(1);
-    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_hidevariable", &VariableBlocks::compileHideVariable)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_variable", &VariableBlocks::compileVariable)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_setvariableto", &VariableBlocks::compileSetVariable)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_changevariableby", &VariableBlocks::compileChangeVariableBy)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_showvariable", &VariableBlocks::compileShowVariable)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_extension.get(), "data_hidevariable", &VariableBlocks::compileHideVariable)).Times(1);
 
     // Monitor names
-    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "data_variable", &VariableBlocks::variableMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_extension.get(), "data_variable", &VariableBlocks::variableMonitorName));
 
     // Monitor change functions
-    EXPECT_CALL(m_engineMock, addMonitorChangeFunction(m_section.get(), "data_variable", &VariableBlocks::changeVariableMonitorValue));
+    EXPECT_CALL(m_engineMock, addMonitorChangeFunction(m_extension.get(), "data_variable", &VariableBlocks::changeVariableMonitorValue));
 
     // Inputs
-    EXPECT_CALL(m_engineMock, addInput(m_section.get(), "VALUE", VariableBlocks::VALUE));
+    EXPECT_CALL(m_engineMock, addInput(m_extension.get(), "VALUE", VariableBlocks::VALUE));
 
     // Fields
-    EXPECT_CALL(m_engineMock, addField(m_section.get(), "VARIABLE", VariableBlocks::VARIABLE));
+    EXPECT_CALL(m_engineMock, addField(m_extension.get(), "VARIABLE", VariableBlocks::VARIABLE));
 
-    m_section->registerBlocks(&m_engineMock);
+    m_extension->registerBlocks(&m_engineMock);
 }
 
 TEST_F(VariableBlocksTest, Variable)
@@ -271,8 +267,12 @@ TEST_F(VariableBlocksTest, ShowVariableImpl)
     Stage stage;
     stage.addVariable(var1);
 
-    Target target;
-    target.addVariable(var2);
+    Sprite sprite;
+    sprite.addVariable(var2);
+
+    Engine fakeEngine;
+    sprite.setEngine(&fakeEngine);
+    auto clone = sprite.clone();
 
     // Global
     VirtualMachine vm1(&stage, &m_engineMock, nullptr);
@@ -299,7 +299,7 @@ TEST_F(VariableBlocksTest, ShowVariableImpl)
     monitor1.setVisible(false);
 
     // Local
-    VirtualMachine vm2(&target, &m_engineMock, nullptr);
+    VirtualMachine vm2(&sprite, &m_engineMock, nullptr);
     vm2.setBytecode(bytecode3);
     vm2.setFunctions(functions);
     vm2.setConstValues(constValues);
@@ -316,6 +316,26 @@ TEST_F(VariableBlocksTest, ShowVariableImpl)
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_FALSE(monitor1.visible());
     ASSERT_TRUE(monitor2.visible());
+
+    // Local - clone
+    monitor2.setVisible(false);
+    VirtualMachine vm3(clone.get(), &m_engineMock, nullptr);
+    vm3.setBytecode(bytecode3);
+    vm3.setFunctions(functions);
+    vm3.setConstValues(constValues);
+    vm3.run();
+
+    ASSERT_EQ(vm3.registerCount(), 0);
+    ASSERT_FALSE(monitor1.visible());
+    ASSERT_FALSE(monitor2.visible());
+
+    vm3.reset();
+    vm3.setBytecode(bytecode4);
+    vm3.run();
+
+    ASSERT_EQ(vm3.registerCount(), 0);
+    ASSERT_FALSE(monitor1.visible());
+    ASSERT_TRUE(monitor2.visible());
 }
 
 TEST_F(VariableBlocksTest, HideVariable)
@@ -374,8 +394,12 @@ TEST_F(VariableBlocksTest, HideVariableImpl)
     Stage stage;
     stage.addVariable(var1);
 
-    Target target;
-    target.addVariable(var2);
+    Sprite sprite;
+    sprite.addVariable(var2);
+
+    Engine fakeEngine;
+    sprite.setEngine(&fakeEngine);
+    auto clone = sprite.clone();
 
     // Global
     VirtualMachine vm1(&stage, &m_engineMock, nullptr);
@@ -402,7 +426,7 @@ TEST_F(VariableBlocksTest, HideVariableImpl)
     monitor1.setVisible(true);
 
     // Local
-    VirtualMachine vm2(&target, &m_engineMock, nullptr);
+    VirtualMachine vm2(&sprite, &m_engineMock, nullptr);
     vm2.setBytecode(bytecode3);
     vm2.setFunctions(functions);
     vm2.setConstValues(constValues);
@@ -419,4 +443,24 @@ TEST_F(VariableBlocksTest, HideVariableImpl)
     ASSERT_EQ(vm2.registerCount(), 0);
     ASSERT_TRUE(monitor1.visible());
     ASSERT_FALSE(monitor2.visible());
+
+    // Local - clone
+    monitor2.setVisible(true);
+    VirtualMachine vm3(clone.get(), &m_engineMock, nullptr);
+    vm3.setBytecode(bytecode3);
+    vm3.setFunctions(functions);
+    vm3.setConstValues(constValues);
+    vm3.run();
+
+    ASSERT_EQ(vm3.registerCount(), 0);
+    ASSERT_TRUE(monitor1.visible());
+    ASSERT_TRUE(monitor2.visible());
+
+    vm3.reset();
+    vm3.setBytecode(bytecode4);
+    vm3.run();
+
+    ASSERT_EQ(vm3.registerCount(), 0);
+    ASSERT_TRUE(monitor1.visible());
+    ASSERT_FALSE(monitor2.visible());
 }
diff --git a/test/compiler/CMakeLists.txt b/test/compiler/CMakeLists.txt
index 9dd42696..9dc335df 100644
--- a/test/compiler/CMakeLists.txt
+++ b/test/compiler/CMakeLists.txt
@@ -1,8 +1,8 @@
 add_executable(
   compiler_test
   compiler_test.cpp
-  testblocksection.cpp
-  testblocksection.h
+  testextension.cpp
+  testextension.h
 )
 
 target_link_libraries(
diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
index e4f3fea5..cbb91a89 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -1,5 +1,6 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/script.h>
+#include <scratchcpp/thread.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/field.h>
@@ -8,12 +9,13 @@
 #include <scratchcpp/list.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/scratchconfiguration.h>
 
 #include "project_p.h"
 #include "engine/internal/engine.h"
 #include "internal/scratch3reader.h"
 #include "../common.h"
-#include "testblocksection.h"
+#include "testextension.h"
 
 #define INIT_COMPILER(engineName, compilerName)                                                                                                                                                        \
     Engine engineName;                                                                                                                                                                                 \
@@ -36,9 +38,15 @@ using namespace libscratchcpp;
 class CompilerTest : public testing::Test
 {
     public:
-        void SetUp() override { m_section = std::make_shared<TestBlockSection>(); }
+        void SetUp() override
+        {
+            m_extension = std::make_shared<TestExtension>();
+            ScratchConfiguration::registerExtension(m_extension);
+        }
 
-        std::shared_ptr<IBlockSection> m_section;
+        void TearDown() override { ScratchConfiguration::removeExtension(m_extension); }
+
+        std::shared_ptr<IExtension> m_extension;
 };
 
 TEST_F(CompilerTest, Constructors)
@@ -342,15 +350,14 @@ TEST_F(CompilerTest, AddNoShadowInput)
 TEST_F(CompilerTest, ResolveInput)
 {
     INIT_COMPILER(engine, compiler);
-
-    engine.registerSection(m_section);
+    engine.setExtensions({ "Test" });
 
     auto block = std::make_shared<Block>("a", "test_block1");
     auto input = std::make_shared<Input>("INPUT1", Input::Type::Shadow);
     input->setPrimaryValue("test");
-    input->setInputId(TestBlockSection::INPUT1);
+    input->setInputId(TestExtension::INPUT1);
     block->addInput(input);
-    block->setCompileFunction(&TestBlockSection::compileTestBlock1);
+    block->setCompileFunction(&TestExtension::compileTestBlock1);
 
     compiler.compile(block);
 
@@ -361,19 +368,18 @@ TEST_F(CompilerTest, ResolveInput)
 TEST_F(CompilerTest, ResolveDropdownMenuInput)
 {
     INIT_COMPILER(engine, compiler);
-
-    engine.registerSection(m_section);
+    engine.setExtensions({ "Test" });
 
     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->setInputId(TestExtension::INPUT1);
     input->setValueBlock(menu);
     menu->addField(optionField);
     block->addInput(input);
-    block->setCompileFunction(&TestBlockSection::compileTestBlock1);
+    block->setCompileFunction(&TestExtension::compileTestBlock1);
 
     compiler.compile(block);
 
@@ -405,15 +411,14 @@ TEST_F(CompilerTest, AddConstValue)
 TEST_F(CompilerTest, ResolveField)
 {
     INIT_COMPILER(engine, compiler);
-
-    engine.registerSection(m_section);
+    engine.setExtensions({ "Test" });
 
     auto block = std::make_shared<Block>("a", "test_block2");
     auto field = std::make_shared<Field>("FIELD1", "test");
-    field->setFieldId(TestBlockSection::FIELD1);
-    field->setSpecialValueId(TestBlockSection::TestValue);
+    field->setFieldId(TestExtension::FIELD1);
+    field->setSpecialValueId(TestExtension::TestValue);
     block->addField(field);
-    block->setCompileFunction(&TestBlockSection::compileTestBlock2);
+    block->setCompileFunction(&TestExtension::compileTestBlock2);
 
     compiler.compile(block);
 
@@ -816,18 +821,18 @@ TEST_F(CompilerTest, MultipleTargets)
     auto sprite1 = engine.targetAt(engine.findTarget("Sprite1"));
     auto script = scripts.at(sprite1->greenFlagBlocks().at(0));
     ASSERT_EQ(script->bytecodeVector().size(), 33);
-    auto vm = script->start();
-    ASSERT_EQ(vm->target(), sprite1);
-    ASSERT_EQ(vm->engine(), &engine);
-    ASSERT_EQ(vm->script(), script.get());
+    auto thread = script->start();
+    ASSERT_EQ(thread->target(), sprite1);
+    ASSERT_EQ(thread->engine(), &engine);
+    ASSERT_EQ(thread->script(), script.get());
 
     auto sprite2 = engine.targetAt(engine.findTarget("Balloon1"));
     script = scripts.at(sprite2->greenFlagBlocks().at(0));
     ASSERT_EQ(script->bytecodeVector().size(), 6);
-    vm = script->start();
-    ASSERT_EQ(vm->target(), sprite2);
-    ASSERT_EQ(vm->engine(), &engine);
-    ASSERT_EQ(vm->script(), script.get());
+    thread = script->start();
+    ASSERT_EQ(thread->target(), sprite2);
+    ASSERT_EQ(thread->engine(), &engine);
+    ASSERT_EQ(thread->script(), script.get());
 }
 
 TEST_F(CompilerTest, EdgeActivatedHatPredicate)
diff --git a/test/compiler/testblocksection.cpp b/test/compiler/testextension.cpp
similarity index 74%
rename from test/compiler/testblocksection.cpp
rename to test/compiler/testextension.cpp
index 9140ef26..cb001061 100644
--- a/test/compiler/testblocksection.cpp
+++ b/test/compiler/testextension.cpp
@@ -4,16 +4,21 @@
 #include <scratchcpp/field.h>
 #include <gtest/gtest.h>
 
-#include "testblocksection.h"
+#include "testextension.h"
 
 using namespace libscratchcpp;
 
-std::string TestBlockSection::name() const
+std::string TestExtension::name() const
 {
     return "Test";
 }
 
-void TestBlockSection::registerBlocks(IEngine *engine)
+std::string TestExtension::description() const
+{
+    return "";
+}
+
+void TestExtension::registerBlocks(IEngine *engine)
 {
     engine->addInput(this, "INPUT1", INPUT1);
 
@@ -25,7 +30,7 @@ void TestBlockSection::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "test_block2", &compileTestBlock2);
 }
 
-void TestBlockSection::compileTestBlock1(Compiler *compiler)
+void TestExtension::compileTestBlock1(Compiler *compiler)
 {
     compiler->addInput(INPUT1);
     ASSERT_EQ(compiler->inputBlock(INPUT1), compiler->input(INPUT1)->valueBlock());
@@ -33,7 +38,7 @@ void TestBlockSection::compileTestBlock1(Compiler *compiler)
     compiler->addInstruction(vm::OP_PRINT);
 }
 
-void TestBlockSection::compileTestBlock2(Compiler *compiler)
+void TestExtension::compileTestBlock2(Compiler *compiler)
 {
     int id = compiler->field(FIELD1)->specialValueId();
 
diff --git a/test/compiler/testblocksection.h b/test/compiler/testextension.h
similarity index 79%
rename from test/compiler/testblocksection.h
rename to test/compiler/testextension.h
index e1679801..c7bdf102 100644
--- a/test/compiler/testblocksection.h
+++ b/test/compiler/testextension.h
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 
 namespace libscratchcpp
 {
 
-class TestBlockSection : public IBlockSection
+class TestExtension : public IExtension
 {
     public:
         enum Inputs
@@ -24,6 +24,7 @@ class TestBlockSection : public IBlockSection
         };
 
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
 
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 86670a44..3b22b0a2 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/project.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
+#include <scratchcpp/textbubble.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/keyevent.h>
@@ -11,6 +12,8 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/script.h>
 #include <scratchcpp/virtualmachine.h>
+#include <scratchcpp/thread.h>
+#include <scratchcpp/scratchconfiguration.h>
 #include <scratch/sound_p.h>
 #include <timermock.h>
 #include <clockmock.h>
@@ -20,7 +23,7 @@
 #include <audioplayermock.h>
 #include <audioloudnessmock.h>
 #include <monitorhandlermock.h>
-#include <blocksectionmock.h>
+#include <extensionmock.h>
 #include <thread>
 
 #include "../common.h"
@@ -28,8 +31,6 @@
 #include "engine/internal/clock.h"
 
 // TODO: Remove this
-#include "blocks/variableblocks.h"
-#include "blocks/listblocks.h"
 #include "blocks/eventblocks.h"
 
 using namespace libscratchcpp;
@@ -51,7 +52,7 @@ class RedrawMock
 class StopMock
 {
     public:
-        MOCK_METHOD(void, threadRemoved, (VirtualMachine *));
+        MOCK_METHOD(void, threadRemoved, (Thread *));
         MOCK_METHOD(void, stopped, ());
 };
 
@@ -72,18 +73,20 @@ TEST(EngineTest, Clear)
 {
     Engine engine;
 
-    auto target1 = std::make_shared<Target>();
-    auto target2 = std::make_shared<Target>();
+    auto target1 = std::make_shared<Sprite>();
+    auto target2 = std::make_shared<Sprite>();
     engine.setTargets({ target1, target2 });
 
     auto broadcast1 = std::make_shared<Broadcast>("", "");
     auto broadcast2 = std::make_shared<Broadcast>("", "");
     engine.setBroadcasts({ broadcast1, broadcast2 });
 
-    auto section = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section, registerBlocks);
-    EXPECT_CALL(*section, onInit);
-    engine.registerSection(section);
+    auto extension = std::make_shared<ExtensionMock>();
+    EXPECT_CALL(*extension, name()).WillRepeatedly(Return("ClearTest"));
+    EXPECT_CALL(*extension, registerBlocks);
+    EXPECT_CALL(*extension, onInit);
+    ScratchConfiguration::registerExtension(extension);
+    engine.setExtensions({ "ClearTest" });
 
     auto monitor1 = std::make_shared<Monitor>("", "");
     auto monitor2 = std::make_shared<Monitor>("", "");
@@ -102,7 +105,7 @@ TEST(EngineTest, Clear)
     ASSERT_TRUE(engine.targets().empty());
     ASSERT_TRUE(engine.broadcasts().empty());
     ASSERT_TRUE(engine.monitors().empty());
-    ASSERT_TRUE(engine.registeredSections().empty());
+    ASSERT_TRUE(engine.extensions().empty());
 
     AddRemoveMonitorMock removeMonitorMock;
     auto handler = std::bind(&AddRemoveMonitorMock::monitorRemoved, &removeMonitorMock, std::placeholders::_1, std::placeholders::_2);
@@ -115,6 +118,8 @@ TEST(EngineTest, Clear)
     EXPECT_CALL(removeMonitorMock, monitorRemoved(monitor4.get(), &iface4));
     engine.clear();
     ASSERT_TRUE(engine.monitors().empty());
+
+    ScratchConfiguration::removeExtension(extension);
 }
 
 TEST(EngineTest, ClearThreadAboutToStopSignal)
@@ -127,9 +132,9 @@ TEST(EngineTest, ClearThreadAboutToStopSignal)
     engine->step();
 
     StopMock stopMock;
-    EXPECT_CALL(stopMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
-        ASSERT_TRUE(vm);
-        ASSERT_FALSE(vm->atEnd());
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](Thread *thread) {
+        ASSERT_TRUE(thread);
+        ASSERT_FALSE(thread->isFinished());
     })));
 
     engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
@@ -146,9 +151,9 @@ TEST(EngineTest, StopThreadAboutToStopSignal)
     engine->step();
 
     StopMock stopMock;
-    EXPECT_CALL(stopMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(3).WillRepeatedly(WithArgs<0>(Invoke([](Thread *vm) {
         ASSERT_TRUE(vm);
-        ASSERT_FALSE(vm->atEnd());
+        ASSERT_FALSE(vm->isFinished());
     })));
 
     engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
@@ -203,22 +208,24 @@ TEST(EngineTest, CompileAndExecuteMonitors)
     m2->setSprite(sprite.get());
     engine.setMonitors({ m1, m2 });
 
-    auto section = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section, registerBlocks);
-    EXPECT_CALL(*section, onInit);
-    engine.registerSection(section);
-    engine.addCompileFunction(section.get(), m1->opcode(), [](Compiler *compiler) { compiler->addConstValue(5.4); });
-    engine.addCompileFunction(section.get(), m2->opcode(), [](Compiler *compiler) { compiler->addConstValue("test"); });
+    auto extension = std::make_shared<ExtensionMock>();
+    EXPECT_CALL(*extension, name()).WillRepeatedly(Return("MonitorTest"));
+    EXPECT_CALL(*extension, registerBlocks);
+    EXPECT_CALL(*extension, onInit);
+    ScratchConfiguration::registerExtension(extension);
+    engine.setExtensions({ "MonitorTest" });
+    engine.addCompileFunction(extension.get(), m1->opcode(), [](Compiler *compiler) { compiler->addConstValue(5.4); });
+    engine.addCompileFunction(extension.get(), m2->opcode(), [](Compiler *compiler) { compiler->addConstValue("test"); });
 
-    engine.addMonitorNameFunction(section.get(), m1->opcode(), [](Block *block) -> const std::string & {
+    engine.addMonitorNameFunction(extension.get(), m1->opcode(), [](Block *block) -> const std::string & {
         static const std::string testStr = "test";
         return testStr;
     });
 
-    engine.addMonitorNameFunction(section.get(), m2->opcode(), [](Block *block) -> const std::string & { return block->opcode(); });
+    engine.addMonitorNameFunction(extension.get(), m2->opcode(), [](Block *block) -> const std::string & { return block->opcode(); });
 
-    engine.addMonitorChangeFunction(section.get(), m1->opcode(), [](Block *block, const Value &newValue) { std::cout << "change 1!" << std::endl; });
-    engine.addMonitorChangeFunction(section.get(), m2->opcode(), [](Block *block, const Value &newValue) { std::cout << "change 2!" << std::endl; });
+    engine.addMonitorChangeFunction(extension.get(), m1->opcode(), [](Block *block, const Value &newValue) { std::cout << "change 1!" << std::endl; });
+    engine.addMonitorChangeFunction(extension.get(), m2->opcode(), [](Block *block, const Value &newValue) { std::cout << "change 2!" << std::endl; });
 
     // Compile the monitor blocks
     engine.compile();
@@ -235,9 +242,9 @@ TEST(EngineTest, CompileAndExecuteMonitors)
     ASSERT_EQ(script2->target(), sprite.get());
     ASSERT_EQ(script2->topBlock(), m2->block());
 
-    ASSERT_EQ(m1->blockSection(), section);
-    ASSERT_EQ(m2->blockSection(), section);
-    ASSERT_FALSE(m3->blockSection());
+    ASSERT_EQ(m1->extension(), extension.get());
+    ASSERT_EQ(m2->extension(), extension.get());
+    ASSERT_FALSE(m3->extension());
 
     ASSERT_EQ(m1->name(), "test");
     ASSERT_EQ(m2->name(), m2->opcode());
@@ -271,6 +278,8 @@ TEST(EngineTest, CompileAndExecuteMonitors)
     EXPECT_CALL(iface2, onValueChanged);
     m2->changeValue(0);
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "change 2!\n");
+
+    ScratchConfiguration::removeExtension(extension);
 }
 
 TEST(EngineTest, IsRunning)
@@ -496,19 +505,19 @@ TEST(EngineTest, ExecutionOrder)
     auto list = GET_LIST(stage, "order");
     ASSERT_EQ(list->size(), 13);
 
-    ASSERT_EQ((*list)[0].toString(), "Sprite2");
-    ASSERT_EQ((*list)[1].toString(), "Sprite3");
-    ASSERT_EQ((*list)[2].toString(), "Sprite1");
-    ASSERT_EQ((*list)[3].toString(), "Stage");
-    ASSERT_EQ((*list)[4].toString(), "Sprite1 1");
-    ASSERT_EQ((*list)[5].toString(), "Sprite1 2");
-    ASSERT_EQ((*list)[6].toString(), "Sprite1 3");
-    ASSERT_EQ((*list)[7].toString(), "Sprite2 msg");
-    ASSERT_EQ((*list)[8].toString(), "Sprite3 msg");
-    ASSERT_EQ((*list)[9].toString(), "Sprite1 1 msg");
-    ASSERT_EQ((*list)[10].toString(), "Sprite1 2 msg");
-    ASSERT_EQ((*list)[11].toString(), "Sprite1 3 msg");
-    ASSERT_EQ((*list)[12].toString(), "Stage msg");
+    ASSERT_EQ(Value((*list)[0]).toString(), "Sprite2");
+    ASSERT_EQ(Value((*list)[1]).toString(), "Sprite3");
+    ASSERT_EQ(Value((*list)[2]).toString(), "Sprite1");
+    ASSERT_EQ(Value((*list)[3]).toString(), "Stage");
+    ASSERT_EQ(Value((*list)[4]).toString(), "Sprite1 1");
+    ASSERT_EQ(Value((*list)[5]).toString(), "Sprite1 2");
+    ASSERT_EQ(Value((*list)[6]).toString(), "Sprite1 3");
+    ASSERT_EQ(Value((*list)[7]).toString(), "Sprite2 msg");
+    ASSERT_EQ(Value((*list)[8]).toString(), "Sprite3 msg");
+    ASSERT_EQ(Value((*list)[9]).toString(), "Sprite1 1 msg");
+    ASSERT_EQ(Value((*list)[10]).toString(), "Sprite1 2 msg");
+    ASSERT_EQ(Value((*list)[11]).toString(), "Sprite1 3 msg");
+    ASSERT_EQ(Value((*list)[12]).toString(), "Stage msg");
 }
 
 TEST(EngineTest, KeyState)
@@ -959,32 +968,27 @@ TEST(EngineTest, Timer)
     engine.run();
 }
 
-TEST(EngineTest, Sections)
+TEST(EngineTest, Extensions)
 {
     Engine engine;
 
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks(&engine));
-    EXPECT_CALL(*section1, onInit(&engine));
-    engine.registerSection(section1);
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks(&engine));
-    EXPECT_CALL(*section2, onInit(&engine));
-    engine.registerSection(section2);
-
-    EXPECT_CALL(*section1, name()).WillOnce(Return("test"));
-    EXPECT_CALL(*section1, registerBlocks).Times(0);
-    EXPECT_CALL(*section1, onInit).Times(0);
-    engine.registerSection(section1); // register existing section
-
-    ASSERT_EQ(engine.registeredSections().size(), 2);
-    if (engine.registeredSections()[0] == section1)
-        ASSERT_EQ(engine.registeredSections()[1].get(), section2.get());
-    else {
-        ASSERT_EQ(engine.registeredSections()[0].get(), section2.get());
-        ASSERT_EQ(engine.registeredSections()[1].get(), section1.get());
-    }
+    auto extension1 = std::make_shared<ExtensionMock>();
+    EXPECT_CALL(*extension1, name()).WillRepeatedly(Return("ext1"));
+    EXPECT_CALL(*extension1, registerBlocks(&engine));
+    EXPECT_CALL(*extension1, onInit(&engine));
+    ScratchConfiguration::registerExtension(extension1);
+
+    auto extension2 = std::make_shared<ExtensionMock>();
+    EXPECT_CALL(*extension2, name()).WillRepeatedly(Return("ext2"));
+    EXPECT_CALL(*extension2, registerBlocks(&engine));
+    EXPECT_CALL(*extension2, onInit(&engine));
+    ScratchConfiguration::registerExtension(extension2);
+
+    engine.setExtensions({ "ext1", "ext2" });
+    ASSERT_EQ(engine.extensions(), std::vector<std::string>({ "ext1", "ext2" }));
+
+    ScratchConfiguration::removeExtension(extension1);
+    ScratchConfiguration::removeExtension(extension2);
 }
 
 unsigned int testFunction1(VirtualMachine *)
@@ -1009,265 +1013,6 @@ TEST(EngineTest, Functions)
     ASSERT_EQ(engine.blockFunctions(), std::vector<BlockFunc>({ &testFunction1, &testFunction2 }));
 }
 
-void compileTest1(Compiler *)
-{
-}
-
-void compileTest2(Compiler *)
-{
-}
-
-TEST(EngineTest, CompileFunctions)
-{
-    Engine engine;
-
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks);
-    EXPECT_CALL(*section1, onInit);
-    engine.registerSection(section1);
-    auto container1 = engine.blockSectionContainer(section1.get());
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks);
-    EXPECT_CALL(*section2, onInit);
-    engine.registerSection(section2);
-    auto container2 = engine.blockSectionContainer(section2.get());
-
-    BlockSectionMock section3;
-
-    engine.addCompileFunction(section1.get(), "test1", &compileTest1);
-    engine.addCompileFunction(section2.get(), "test2", &compileTest2);
-    engine.addCompileFunction(section1.get(), "test1", &compileTest1);
-    engine.addCompileFunction(&section3, "test1", &compileTest1);
-
-    ASSERT_EQ(container1->resolveBlockCompileFunc("test1"), &compileTest1);
-    ASSERT_EQ(container1->resolveBlockCompileFunc("test2"), nullptr);
-    ASSERT_EQ(container2->resolveBlockCompileFunc("test1"), nullptr);
-    ASSERT_EQ(container2->resolveBlockCompileFunc("test2"), &compileTest2);
-}
-
-TEST(EngineTest, HatPredicateCompileFunctions)
-{
-    Engine engine;
-
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks);
-    EXPECT_CALL(*section1, onInit);
-    engine.registerSection(section1);
-    auto container1 = engine.blockSectionContainer(section1.get());
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks);
-    EXPECT_CALL(*section2, onInit);
-    engine.registerSection(section2);
-    auto container2 = engine.blockSectionContainer(section2.get());
-
-    BlockSectionMock section3;
-
-    engine.addHatPredicateCompileFunction(section1.get(), "test1", &compileTest1);
-    engine.addHatPredicateCompileFunction(section2.get(), "test2", &compileTest2);
-    engine.addHatPredicateCompileFunction(section1.get(), "test1", &compileTest1);
-    engine.addHatPredicateCompileFunction(&section3, "test1", &compileTest1);
-
-    ASSERT_EQ(container1->resolveHatPredicateCompileFunc("test1"), &compileTest1);
-    ASSERT_EQ(container1->resolveHatPredicateCompileFunc("test2"), nullptr);
-    ASSERT_EQ(container2->resolveHatPredicateCompileFunc("test1"), nullptr);
-    ASSERT_EQ(container2->resolveHatPredicateCompileFunc("test2"), &compileTest2);
-}
-
-TEST(EngineTest, MonitorNameFunctions)
-{
-    Engine engine;
-
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks);
-    EXPECT_CALL(*section1, onInit);
-    engine.registerSection(section1);
-    auto container1 = engine.blockSectionContainer(section1.get());
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks);
-    EXPECT_CALL(*section2, onInit);
-    engine.registerSection(section2);
-    auto container2 = engine.blockSectionContainer(section2.get());
-
-    BlockSectionMock section3;
-
-    MonitorNameFunc f1 = [](Block *) -> const std::string & {
-        static const std::string ret;
-        return ret;
-    };
-
-    MonitorNameFunc f2 = [](Block *) -> const std::string & {
-        static const std::string ret;
-        return ret;
-    };
-
-    engine.addMonitorNameFunction(section1.get(), "test1", f1);
-    engine.addMonitorNameFunction(section2.get(), "test2", f2);
-    engine.addMonitorNameFunction(section1.get(), "test1", f1);
-    engine.addMonitorNameFunction(&section3, "test1", f1);
-
-    ASSERT_EQ(container1->resolveMonitorNameFunc("test1"), f1);
-    ASSERT_EQ(container1->resolveMonitorNameFunc("test2"), nullptr);
-    ASSERT_EQ(container2->resolveMonitorNameFunc("test1"), nullptr);
-    ASSERT_EQ(container2->resolveMonitorNameFunc("test2"), f2);
-}
-
-TEST(EngineTest, MonitorChangeFunctions)
-{
-    Engine engine;
-
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks);
-    EXPECT_CALL(*section1, onInit);
-    engine.registerSection(section1);
-    auto container1 = engine.blockSectionContainer(section1.get());
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks);
-    EXPECT_CALL(*section2, onInit);
-    engine.registerSection(section2);
-    auto container2 = engine.blockSectionContainer(section2.get());
-
-    BlockSectionMock section3;
-
-    MonitorChangeFunc f1 = [](Block *, const Value &) {};
-    MonitorChangeFunc f2 = [](Block *, const Value &) {};
-
-    engine.addMonitorChangeFunction(section1.get(), "test1", f1);
-    engine.addMonitorChangeFunction(section2.get(), "test2", f2);
-    engine.addMonitorChangeFunction(section1.get(), "test1", f1);
-    engine.addMonitorChangeFunction(&section3, "test1", f1);
-
-    ASSERT_EQ(container1->resolveMonitorChangeFunc("test1"), f1);
-    ASSERT_EQ(container1->resolveMonitorChangeFunc("test2"), nullptr);
-    ASSERT_EQ(container2->resolveMonitorChangeFunc("test1"), nullptr);
-    ASSERT_EQ(container2->resolveMonitorChangeFunc("test2"), f2);
-}
-
-TEST(EngineTest, HatBlocks)
-{
-    Engine engine;
-
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks);
-    EXPECT_CALL(*section1, onInit);
-    engine.registerSection(section1);
-    auto container1 = engine.blockSectionContainer(section1.get());
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks);
-    EXPECT_CALL(*section2, onInit);
-    engine.registerSection(section2);
-    auto container2 = engine.blockSectionContainer(section2.get());
-
-    BlockSectionMock section3;
-
-    engine.addHatBlock(section1.get(), "test1");
-    engine.addHatBlock(section2.get(), "test2");
-    engine.addHatBlock(section1.get(), "test1");
-    engine.addHatBlock(&section3, "test1");
-
-    ASSERT_NE(container1->resolveBlockCompileFunc("test1"), nullptr);
-    ASSERT_EQ(container1->resolveBlockCompileFunc("test2"), nullptr);
-    ASSERT_EQ(container2->resolveBlockCompileFunc("test1"), nullptr);
-    ASSERT_NE(container2->resolveBlockCompileFunc("test2"), nullptr);
-}
-
-TEST(EngineTest, Inputs)
-{
-    Engine engine;
-
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks);
-    EXPECT_CALL(*section1, onInit);
-    engine.registerSection(section1);
-    auto container1 = engine.blockSectionContainer(section1.get());
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks);
-    EXPECT_CALL(*section2, onInit);
-    engine.registerSection(section2);
-    auto container2 = engine.blockSectionContainer(section2.get());
-
-    BlockSectionMock section3;
-
-    engine.addInput(section1.get(), "VALUE1", 1);
-    engine.addInput(section2.get(), "VALUE2", 2);
-    engine.addInput(section1.get(), "VALUE1", 3); // change ID of existing input
-    engine.addInput(&section3, "VALUE3", 4);
-
-    ASSERT_EQ(container1->resolveInput("VALUE1"), 3);
-    ASSERT_EQ(container1->resolveInput("VALUE2"), -1);
-    ASSERT_EQ(container1->resolveInput("VALUE3"), -1);
-    ASSERT_EQ(container2->resolveInput("VALUE1"), -1);
-    ASSERT_EQ(container2->resolveInput("VALUE2"), 2);
-    ASSERT_EQ(container2->resolveInput("VALUE3"), -1);
-}
-
-TEST(EngineTest, Fields)
-{
-    Engine engine;
-
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks);
-    EXPECT_CALL(*section1, onInit);
-    engine.registerSection(section1);
-    auto container1 = engine.blockSectionContainer(section1.get());
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks);
-    EXPECT_CALL(*section2, onInit);
-    engine.registerSection(section2);
-    auto container2 = engine.blockSectionContainer(section2.get());
-
-    BlockSectionMock section3;
-
-    engine.addField(section1.get(), "VALUE1", 1);
-    engine.addField(section2.get(), "VALUE2", 2);
-    engine.addField(section1.get(), "VALUE1", 3); // change ID of existing field
-    engine.addField(&section3, "VALUE3", 4);
-
-    ASSERT_EQ(container1->resolveField("VALUE1"), 3);
-    ASSERT_EQ(container1->resolveField("VALUE2"), -1);
-    ASSERT_EQ(container1->resolveField("VALUE3"), -1);
-    ASSERT_EQ(container2->resolveField("VALUE1"), -1);
-    ASSERT_EQ(container2->resolveField("VALUE2"), 2);
-    ASSERT_EQ(container2->resolveField("VALUE3"), -1);
-}
-
-TEST(EngineTest, FieldValues)
-{
-    Engine engine;
-
-    auto section1 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section1, registerBlocks);
-    EXPECT_CALL(*section1, onInit);
-    engine.registerSection(section1);
-    auto container1 = engine.blockSectionContainer(section1.get());
-
-    auto section2 = std::make_shared<BlockSectionMock>();
-    EXPECT_CALL(*section2, registerBlocks);
-    EXPECT_CALL(*section2, onInit);
-    engine.registerSection(section2);
-    auto container2 = engine.blockSectionContainer(section2.get());
-
-    BlockSectionMock section3;
-
-    engine.addFieldValue(section1.get(), "value1", 1);
-    engine.addFieldValue(section2.get(), "value2", 2);
-    engine.addFieldValue(section1.get(), "value1", 3); // change ID of existing field value
-    engine.addFieldValue(&section3, "value3", 4);
-
-    ASSERT_EQ(container1->resolveFieldValue("value1"), 3);
-    ASSERT_EQ(container1->resolveFieldValue("value2"), -1);
-    ASSERT_EQ(container1->resolveFieldValue("value3"), -1);
-    ASSERT_EQ(container2->resolveFieldValue("value1"), -1);
-    ASSERT_EQ(container2->resolveFieldValue("value2"), 2);
-    ASSERT_EQ(container2->resolveFieldValue("value3"), -1);
-}
-
 TEST(EngineTest, Broadcasts)
 {
     Engine engine;
@@ -1411,16 +1156,21 @@ TEST(EngineTest, Targets)
     Engine engine;
     ASSERT_TRUE(engine.targets().empty());
 
-    auto t1 = std::make_shared<Target>();
+    auto t1 = std::make_shared<Sprite>();
     t1->setName("Sprite1");
-    auto t2 = std::make_shared<Target>();
+    t1->setVisible(true);
+    t1->setLayerOrder(3);
+    auto t2 = std::make_shared<Sprite>();
     auto block1 = std::make_shared<Block>("", "");
     auto block2 = std::make_shared<Block>("", "");
     t2->setName("Sprite2");
+    t2->setVisible(false);
+    t2->setLayerOrder(1);
     t2->addBlock(block1);
     t2->addBlock(block2);
     auto t3 = std::make_shared<Stage>();
     t3->setName("Stage");
+    t3->setLayerOrder(0);
     engine.setTargets({ t1, t2, t3 });
 
     ASSERT_EQ(engine.targets(), std::vector<std::shared_ptr<Target>>({ t1, t2, t3 }));
@@ -1436,16 +1186,25 @@ TEST(EngineTest, Targets)
     ASSERT_EQ(engine.findTarget("Stage"), -1);
     ASSERT_EQ(engine.findTarget("_stage_"), 2);
 
-    auto t4 = std::make_shared<Target>();
+    auto t4 = std::make_shared<Sprite>();
     t4->setName("Stage");
+    t4->setVisible(true);
+    t4->setLayerOrder(2);
     engine.setTargets({ t1, t2, t4 });
     ASSERT_EQ(engine.findTarget("Stage"), 2);
     ASSERT_EQ(engine.findTarget("_stage_"), -1);
 
+    std::vector<Target *> visibleTargets;
+    engine.getVisibleTargets(visibleTargets);
+    ASSERT_EQ(visibleTargets, std::vector<Target *>({ t1.get(), t4.get() }));
+
     engine.setTargets({ t1, t2, t3, t4 });
     ASSERT_EQ(engine.findTarget("Stage"), 3);
     ASSERT_EQ(engine.findTarget("_stage_"), 2);
 
+    engine.getVisibleTargets(visibleTargets);
+    ASSERT_EQ(visibleTargets, std::vector<Target *>({ t1.get(), t4.get(), t3.get() }));
+
     ASSERT_EQ(t1->engine(), &engine);
     ASSERT_EQ(t2->engine(), &engine);
     ASSERT_EQ(t3->engine(), &engine);
@@ -1479,161 +1238,269 @@ void createTargets(Engine *engine, std::vector<Sprite *> &sprites)
     ASSERT_EQ(sprites[4]->layerOrder(), 2);
 }
 
-TEST(EngineTest, MoveSpriteToFront)
+TEST(EngineTest, MoveDrawableToFront)
 {
     Engine engine;
     std::vector<Sprite *> sprites;
     createTargets(&engine, sprites);
 
-    engine.moveSpriteToFront(sprites[2]);
+    engine.moveDrawableToFront(sprites[2]);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 4);
-    ASSERT_EQ(sprites[2]->layerOrder(), 5);
+    ASSERT_EQ(sprites[2]->layerOrder(), 11);
     ASSERT_EQ(sprites[3]->layerOrder(), 3);
     ASSERT_EQ(sprites[4]->layerOrder(), 2);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 6);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 10);
 
     for (int i = 0; i < 2; i++) {
-        engine.moveSpriteToFront(sprites[0]);
-        ASSERT_EQ(sprites[0]->layerOrder(), 5);
+        engine.moveDrawableToFront(sprites[0]);
+        ASSERT_EQ(sprites[0]->layerOrder(), 11);
         ASSERT_EQ(sprites[1]->layerOrder(), 3);
-        ASSERT_EQ(sprites[2]->layerOrder(), 4);
+        ASSERT_EQ(sprites[2]->layerOrder(), 10);
         ASSERT_EQ(sprites[3]->layerOrder(), 2);
         ASSERT_EQ(sprites[4]->layerOrder(), 1);
+        ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 5);
+        ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 6);
+        ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 7);
+        ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 8);
+        ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 9);
     }
 
+    engine.moveDrawableToFront(sprites[0]->bubble());
+    ASSERT_EQ(sprites[0]->layerOrder(), 10);
+    ASSERT_EQ(sprites[1]->layerOrder(), 3);
+    ASSERT_EQ(sprites[2]->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->layerOrder(), 2);
+    ASSERT_EQ(sprites[4]->layerOrder(), 1);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 11);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 5);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 6);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 8);
+
     auto stage = std::make_shared<Stage>();
     stage->setLayerOrder(0);
     auto sprite = std::make_shared<Sprite>();
     sprite->setLayerOrder(1);
 
     engine.setTargets({ stage, sprite });
-    engine.moveSpriteToFront(sprite.get());
-    ASSERT_EQ(sprite->layerOrder(), 1);
+    engine.moveDrawableToFront(sprite.get());
+    ASSERT_EQ(sprite->layerOrder(), 3);
 }
 
-TEST(EngineTest, MoveSpriteToBack)
+TEST(EngineTest, MoveDrawableToBack)
 {
     Engine engine;
     std::vector<Sprite *> sprites;
     createTargets(&engine, sprites);
 
-    engine.moveSpriteToBack(sprites[2]);
+    engine.moveDrawableToBack(sprites[2]);
     ASSERT_EQ(sprites[0]->layerOrder(), 2);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
     ASSERT_EQ(sprites[2]->layerOrder(), 1);
     ASSERT_EQ(sprites[3]->layerOrder(), 4);
     ASSERT_EQ(sprites[4]->layerOrder(), 3);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
 
     for (int i = 0; i < 1; i++) {
-        engine.moveSpriteToBack(sprites[1]);
+        engine.moveDrawableToBack(sprites[1]);
         ASSERT_EQ(sprites[0]->layerOrder(), 3);
         ASSERT_EQ(sprites[1]->layerOrder(), 1);
         ASSERT_EQ(sprites[2]->layerOrder(), 2);
         ASSERT_EQ(sprites[3]->layerOrder(), 5);
         ASSERT_EQ(sprites[4]->layerOrder(), 4);
+        ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+        ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+        ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+        ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+        ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
     }
 
+    engine.moveDrawableToBack(sprites[2]->bubble());
+    ASSERT_EQ(sprites[0]->layerOrder(), 4);
+    ASSERT_EQ(sprites[1]->layerOrder(), 2);
+    ASSERT_EQ(sprites[2]->layerOrder(), 3);
+    ASSERT_EQ(sprites[3]->layerOrder(), 6);
+    ASSERT_EQ(sprites[4]->layerOrder(), 5);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 1);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
+
     auto stage = std::make_shared<Stage>();
     stage->setLayerOrder(0);
     auto sprite = std::make_shared<Sprite>();
     sprite->setLayerOrder(1);
 
     engine.setTargets({ stage, sprite });
-    engine.moveSpriteToBack(sprite.get());
+    engine.moveDrawableToBack(sprite.get());
     ASSERT_EQ(sprite->layerOrder(), 1);
 }
 
-TEST(EngineTest, MoveSpriteForwardLayers)
+TEST(EngineTest, MoveDrawableForwardLayers)
 {
     Engine engine;
     std::vector<Sprite *> sprites;
     createTargets(&engine, sprites);
 
-    engine.moveSpriteForwardLayers(sprites[4], 2);
+    engine.moveDrawableForwardLayers(sprites[4], 2);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
     ASSERT_EQ(sprites[2]->layerOrder(), 2);
     ASSERT_EQ(sprites[3]->layerOrder(), 3);
     ASSERT_EQ(sprites[4]->layerOrder(), 4);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
 
-    engine.moveSpriteForwardLayers(sprites[4], 2);
+    engine.moveDrawableForwardLayers(sprites[4], 2);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 4);
     ASSERT_EQ(sprites[2]->layerOrder(), 2);
     ASSERT_EQ(sprites[3]->layerOrder(), 3);
-    ASSERT_EQ(sprites[4]->layerOrder(), 5);
-
-    engine.moveSpriteForwardLayers(sprites[4], -3);
+    ASSERT_EQ(sprites[4]->layerOrder(), 6);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
+
+    engine.moveDrawableForwardLayers(sprites[4], -3);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
-    ASSERT_EQ(sprites[2]->layerOrder(), 3);
+    ASSERT_EQ(sprites[2]->layerOrder(), 2);
     ASSERT_EQ(sprites[3]->layerOrder(), 4);
-    ASSERT_EQ(sprites[4]->layerOrder(), 2);
+    ASSERT_EQ(sprites[4]->layerOrder(), 3);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
 
-    engine.moveSpriteForwardLayers(sprites[2], -3);
+    engine.moveDrawableForwardLayers(sprites[2], -3);
     ASSERT_EQ(sprites[0]->layerOrder(), 2);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
     ASSERT_EQ(sprites[2]->layerOrder(), 1);
     ASSERT_EQ(sprites[3]->layerOrder(), 4);
     ASSERT_EQ(sprites[4]->layerOrder(), 3);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
+
+    engine.moveDrawableForwardLayers(sprites[0]->bubble(), 3);
+    ASSERT_EQ(sprites[0]->layerOrder(), 2);
+    ASSERT_EQ(sprites[1]->layerOrder(), 5);
+    ASSERT_EQ(sprites[2]->layerOrder(), 1);
+    ASSERT_EQ(sprites[3]->layerOrder(), 4);
+    ASSERT_EQ(sprites[4]->layerOrder(), 3);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
 }
 
-TEST(EngineTest, MoveSpriteBackwardLayers)
+TEST(EngineTest, MoveDrawableBackwardLayers)
 {
     Engine engine;
     std::vector<Sprite *> sprites;
     createTargets(&engine, sprites);
 
-    engine.moveSpriteBackwardLayers(sprites[4], -2);
+    engine.moveDrawableBackwardLayers(sprites[4], -2);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
     ASSERT_EQ(sprites[2]->layerOrder(), 2);
     ASSERT_EQ(sprites[3]->layerOrder(), 3);
     ASSERT_EQ(sprites[4]->layerOrder(), 4);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
 
-    engine.moveSpriteBackwardLayers(sprites[4], -2);
+    engine.moveDrawableBackwardLayers(sprites[4], -2);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 4);
     ASSERT_EQ(sprites[2]->layerOrder(), 2);
     ASSERT_EQ(sprites[3]->layerOrder(), 3);
-    ASSERT_EQ(sprites[4]->layerOrder(), 5);
-
-    engine.moveSpriteBackwardLayers(sprites[4], 3);
+    ASSERT_EQ(sprites[4]->layerOrder(), 6);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
+
+    engine.moveDrawableBackwardLayers(sprites[4], 3);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
-    ASSERT_EQ(sprites[2]->layerOrder(), 3);
+    ASSERT_EQ(sprites[2]->layerOrder(), 2);
     ASSERT_EQ(sprites[3]->layerOrder(), 4);
-    ASSERT_EQ(sprites[4]->layerOrder(), 2);
+    ASSERT_EQ(sprites[4]->layerOrder(), 3);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
 
-    engine.moveSpriteBackwardLayers(sprites[2], 3);
+    engine.moveDrawableBackwardLayers(sprites[2], 3);
     ASSERT_EQ(sprites[0]->layerOrder(), 2);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
     ASSERT_EQ(sprites[2]->layerOrder(), 1);
     ASSERT_EQ(sprites[3]->layerOrder(), 4);
     ASSERT_EQ(sprites[4]->layerOrder(), 3);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
+
+    engine.moveDrawableBackwardLayers(sprites[0]->bubble(), -3);
+    ASSERT_EQ(sprites[0]->layerOrder(), 2);
+    ASSERT_EQ(sprites[1]->layerOrder(), 5);
+    ASSERT_EQ(sprites[2]->layerOrder(), 1);
+    ASSERT_EQ(sprites[3]->layerOrder(), 4);
+    ASSERT_EQ(sprites[4]->layerOrder(), 3);
+    ASSERT_EQ(sprites[0]->bubble()->layerOrder(), 10);
+    ASSERT_EQ(sprites[1]->bubble()->layerOrder(), 7);
+    ASSERT_EQ(sprites[2]->bubble()->layerOrder(), 8);
+    ASSERT_EQ(sprites[3]->bubble()->layerOrder(), 9);
+    ASSERT_EQ(sprites[4]->bubble()->layerOrder(), 11);
 }
 
-TEST(EngineTest, MoveSpriteBehindOther)
+TEST(EngineTest, MoveDrawableBehindOther)
 {
     Engine engine;
     std::vector<Sprite *> sprites;
     createTargets(&engine, sprites);
 
-    engine.moveSpriteBehindOther(sprites[4], sprites[3]);
+    engine.moveDrawableBehindOther(sprites[4], sprites[3]);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
     ASSERT_EQ(sprites[2]->layerOrder(), 2);
     ASSERT_EQ(sprites[3]->layerOrder(), 4);
     ASSERT_EQ(sprites[4]->layerOrder(), 3);
 
-    engine.moveSpriteBehindOther(sprites[3], sprites[2]);
+    engine.moveDrawableBehindOther(sprites[3], sprites[2]);
     ASSERT_EQ(sprites[0]->layerOrder(), 1);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
     ASSERT_EQ(sprites[2]->layerOrder(), 3);
     ASSERT_EQ(sprites[3]->layerOrder(), 2);
     ASSERT_EQ(sprites[4]->layerOrder(), 4);
 
-    engine.moveSpriteBehindOther(sprites[4], sprites[0]);
+    engine.moveDrawableBehindOther(sprites[4], sprites[0]);
     ASSERT_EQ(sprites[0]->layerOrder(), 2);
     ASSERT_EQ(sprites[1]->layerOrder(), 5);
     ASSERT_EQ(sprites[2]->layerOrder(), 4);
@@ -1693,6 +1560,14 @@ TEST(EngineTest, Monitors)
 
 TEST(EngineTest, CreateMissingMonitors)
 {
+    static constexpr const char *VARIABLE_OPCODE = "data_variable";
+    static constexpr const char *VARIABLE_FIELD_NAME = "VARIABLE";
+    static constexpr int VARIABLE_FIELD_ID = 1;
+
+    static constexpr const char *LIST_OPCODE = "data_listcontents";
+    static constexpr const char *LIST_FIELD_NAME = "LIST";
+    static constexpr int LIST_FIELD_ID = 2;
+
     auto var1 = std::make_shared<Variable>("a", "var1");
     auto var2 = std::make_shared<Variable>("b", "var2");
     auto var3 = std::make_shared<Variable>("c", "var3");
@@ -1715,16 +1590,19 @@ TEST(EngineTest, CreateMissingMonitors)
     auto m3 = std::make_shared<Monitor>(list2->id(), "data_listcontents");
 
     auto checkVariableMonitor = [](std::shared_ptr<Monitor> monitor, std::shared_ptr<Variable> var) {
+        ASSERT_EQ(var->monitor(), monitor.get());
+
         auto block = monitor->block();
         ASSERT_EQ(monitor->id(), var->id());
         ASSERT_EQ(monitor->opcode(), "data_variable");
         ASSERT_EQ(monitor->mode(), Monitor::Mode::Default);
+        ASSERT_TRUE(monitor->needsAutoPosition());
         ASSERT_FALSE(monitor->visible());
         ASSERT_EQ(block->fields().size(), 1);
 
         auto field = block->fieldAt(0);
-        ASSERT_EQ(field->name(), "VARIABLE");
-        ASSERT_EQ(field->fieldId(), VariableBlocks::VARIABLE);
+        ASSERT_EQ(field->name(), VARIABLE_FIELD_NAME);
+        ASSERT_EQ(field->fieldId(), VARIABLE_FIELD_ID);
         ASSERT_EQ(field->value(), var->name());
         ASSERT_EQ(field->valuePtr(), var);
 
@@ -1735,16 +1613,19 @@ TEST(EngineTest, CreateMissingMonitors)
     };
 
     auto checkListMonitor = [](std::shared_ptr<Monitor> monitor, std::shared_ptr<List> list) {
+        ASSERT_EQ(list->monitor(), monitor.get());
+
         auto block = monitor->block();
         ASSERT_EQ(monitor->id(), list->id());
         ASSERT_EQ(monitor->opcode(), "data_listcontents");
-        ASSERT_EQ(monitor->mode(), Monitor::Mode::Default);
+        ASSERT_EQ(monitor->mode(), Monitor::Mode::List);
+        ASSERT_TRUE(monitor->needsAutoPosition());
         ASSERT_FALSE(monitor->visible());
         ASSERT_EQ(block->fields().size(), 1);
 
         auto field = block->fieldAt(0);
-        ASSERT_EQ(field->name(), "LIST");
-        ASSERT_EQ(field->fieldId(), ListBlocks::LIST);
+        ASSERT_EQ(field->name(), LIST_FIELD_NAME);
+        ASSERT_EQ(field->fieldId(), LIST_FIELD_ID);
         ASSERT_EQ(field->value(), list->name());
         ASSERT_EQ(field->valuePtr(), list);
 
@@ -1754,40 +1635,34 @@ TEST(EngineTest, CreateMissingMonitors)
             ASSERT_EQ(monitor->sprite(), dynamic_cast<Sprite *>(list->target()));
     };
 
-    // Set monitors after setting targets
     {
         Engine engine;
         engine.setTargets({ target1, target2 });
         engine.setMonitors({ m1, m2, m3 });
 
         const auto &monitors = engine.monitors();
-        ASSERT_EQ(monitors.size(), 7);
+        ASSERT_EQ(monitors.size(), 3);
         ASSERT_EQ(monitors[0], m1);
         ASSERT_EQ(monitors[1], m2);
         ASSERT_EQ(monitors[2], m3);
-        checkVariableMonitor(monitors[3], var2);
-        checkListMonitor(monitors[4], list1);
-        checkVariableMonitor(monitors[5], var4);
-        checkVariableMonitor(monitors[6], var5);
-    }
 
-    // Set monitors before setting targets
-    {
-        Engine engine;
-        engine.setMonitors({ m1, m2, m3 });
-        engine.setTargets({ target1, target2 });
+        engine.createVariableMonitor(var2, VARIABLE_OPCODE, VARIABLE_FIELD_NAME, VARIABLE_FIELD_ID, nullptr);
+        engine.createListMonitor(list1, LIST_OPCODE, LIST_FIELD_NAME, LIST_FIELD_ID, nullptr);
+        engine.createVariableMonitor(var4, VARIABLE_OPCODE, VARIABLE_FIELD_NAME, VARIABLE_FIELD_ID, nullptr);
+        engine.createVariableMonitor(var5, VARIABLE_OPCODE, VARIABLE_FIELD_NAME, VARIABLE_FIELD_ID, nullptr);
 
-        const auto &monitors = engine.monitors();
         ASSERT_EQ(monitors.size(), 7);
-        ASSERT_EQ(monitors[0], m1);
-        ASSERT_EQ(monitors[1], m2);
-        ASSERT_EQ(monitors[2], m3);
         checkVariableMonitor(monitors[3], var2);
         checkListMonitor(monitors[4], list1);
         checkVariableMonitor(monitors[5], var4);
         checkVariableMonitor(monitors[6], var5);
     }
 
+    var2->setMonitor(nullptr);
+    list1->setMonitor(nullptr);
+    var4->setMonitor(nullptr);
+    var5->setMonitor(nullptr);
+
     {
         Engine engine;
         AddRemoveMonitorMock addMonitorMock;
@@ -1801,7 +1676,11 @@ TEST(EngineTest, CreateMissingMonitors)
 
         Monitor *m4, *m5, *m6, *m7;
         EXPECT_CALL(addMonitorMock, monitorAdded(_)).WillOnce(SaveArg<0>(&m4)).WillOnce(SaveArg<0>(&m5)).WillOnce(SaveArg<0>(&m6)).WillOnce(SaveArg<0>(&m7));
-        engine.setTargets({ target1, target2 });
+
+        engine.createVariableMonitor(var2, VARIABLE_OPCODE, VARIABLE_FIELD_NAME, VARIABLE_FIELD_ID, nullptr);
+        engine.createListMonitor(list1, LIST_OPCODE, LIST_FIELD_NAME, LIST_FIELD_ID, nullptr);
+        engine.createVariableMonitor(var4, VARIABLE_OPCODE, VARIABLE_FIELD_NAME, VARIABLE_FIELD_ID, nullptr);
+        engine.createVariableMonitor(var5, VARIABLE_OPCODE, VARIABLE_FIELD_NAME, VARIABLE_FIELD_ID, nullptr);
 
         const auto &monitors = engine.monitors();
         ASSERT_EQ(monitors.size(), 7);
@@ -1845,9 +1724,9 @@ TEST(EngineTest, Clones)
 
     for (int i = 0; i < list->size(); i++) {
         if (i < 10)
-            ASSERT_EQ((*list)[i].toInt(), 1);
+            ASSERT_EQ(value_toInt(&(*list)[i]), 1);
         else
-            ASSERT_EQ((*list)[i].toInt(), 2);
+            ASSERT_EQ(value_toInt(&(*list)[i]), 2);
     }
 
     ASSERT_LIST(stage, "log2");
@@ -1855,9 +1734,9 @@ TEST(EngineTest, Clones)
 
     for (int i = 0; i < list->size(); i++) {
         if (i < 10)
-            ASSERT_EQ((*list)[i].toInt(), 1);
+            ASSERT_EQ(value_toInt(&(*list)[i]), 1);
         else
-            ASSERT_EQ((*list)[i].toString(), "12");
+            ASSERT_EQ(Value((*list)[i]).toString(), "12");
     }
 }
 
@@ -1953,9 +1832,9 @@ TEST(EngineTest, BroadcastsProject)
     auto engine = p.engine();
 
     StopMock stopMock;
-    EXPECT_CALL(stopMock, threadRemoved(_)).Times(21).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
-        ASSERT_TRUE(vm);
-        ASSERT_FALSE(vm->atEnd());
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(21).WillRepeatedly(WithArgs<0>(Invoke([](Thread *thread) {
+        ASSERT_TRUE(thread);
+        ASSERT_FALSE(thread->isFinished());
     })));
 
     engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
@@ -2001,9 +1880,9 @@ TEST(EngineTest, StopAllBypass)
     auto engine = p.engine();
 
     StopMock stopMock;
-    EXPECT_CALL(stopMock, threadRemoved(_)).Times(2).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
-        ASSERT_TRUE(vm);
-        ASSERT_FALSE(vm->atEnd());
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(2).WillRepeatedly(WithArgs<0>(Invoke([](Thread *thread) {
+        ASSERT_TRUE(thread);
+        ASSERT_FALSE(thread->isFinished());
     })));
 
     engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
@@ -2029,9 +1908,9 @@ TEST(EngineTest, StopOtherScriptsInSprite)
     auto engine = p.engine();
 
     StopMock stopMock;
-    EXPECT_CALL(stopMock, threadRemoved(_)).Times(4).WillRepeatedly(WithArgs<0>(Invoke([](VirtualMachine *vm) {
-        ASSERT_TRUE(vm);
-        ASSERT_FALSE(vm->atEnd());
+    EXPECT_CALL(stopMock, threadRemoved(_)).Times(4).WillRepeatedly(WithArgs<0>(Invoke([](Thread *thread) {
+        ASSERT_TRUE(thread);
+        ASSERT_FALSE(thread->isFinished());
     })));
 
     engine->threadAboutToStop().connect(&StopMock::threadRemoved, &stopMock);
@@ -2238,14 +2117,15 @@ TEST(EngineTest, StopBeforeStarting)
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
 
-    engine->broadcast(0);
+    Thread fakeThread(nullptr, nullptr, nullptr);
+    engine->broadcast(0, &fakeThread, false);
     engine->step();
 
     ASSERT_VAR(stage, "test");
     ASSERT_FALSE(GET_VAR(stage, "test")->value().toBool());
 
     GET_VAR(stage, "test")->setValue(true);
-    engine->broadcast(0);
+    engine->broadcast(0, &fakeThread, false);
     engine->start();
     engine->step();
     ASSERT_VAR(stage, "test");
@@ -2350,3 +2230,22 @@ TEST(EngineTest, DuplicateVariableOrListIDs)
     ASSERT_VAR(stage, "passed");
     ASSERT_TRUE(GET_VAR(stage, "passed")->value().toBool());
 }
+
+TEST(EngineTest, BroadcastStopsWaitBlocks)
+{
+    // Regtest for #563
+    Project p("regtest_projects/563_broadcast_stops_wait_blocks.sb3");
+    ASSERT_TRUE(p.load());
+
+    auto engine = p.engine();
+
+    Stage *stage = engine->stage();
+    ASSERT_TRUE(stage);
+
+    engine->run();
+
+    ASSERT_VAR(stage, "broadcast_passed");
+    ASSERT_TRUE(GET_VAR(stage, "broadcast_passed")->value().toBool());
+    ASSERT_VAR(stage, "backdrop_passed");
+    ASSERT_TRUE(GET_VAR(stage, "backdrop_passed")->value().toBool());
+}
diff --git a/test/extensions/CMakeLists.txt b/test/extensions/CMakeLists.txt
index a337769d..6b4d320b 100644
--- a/test/extensions/CMakeLists.txt
+++ b/test/extensions/CMakeLists.txt
@@ -15,21 +15,3 @@ target_link_libraries(
 )
 
 gtest_discover_tests(iextension_test)
-
-# iblocksection_test
-add_executable(
-  iblocksection_test
-  iblocksection_test.cpp
-  testsection.cpp
-  testsection.h
-)
-
-target_link_libraries(
-  iblocksection_test
-  GTest::gtest_main
-  GTest::gmock_main
-  scratchcpp
-  scratchcpp_mocks
-)
-
-gtest_discover_tests(iblocksection_test)
diff --git a/test/extensions/iblocksection_test.cpp b/test/extensions/iblocksection_test.cpp
deleted file mode 100644
index 869a595c..00000000
--- a/test/extensions/iblocksection_test.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <enginemock.h>
-
-#include "../common.h"
-#include "testsection.h"
-
-using namespace libscratchcpp;
-
-class IBlockSectionTest : public testing::Test
-{
-    public:
-        void SetUp() override { m_section = std::make_unique<TestSection>(); };
-
-        std::unique_ptr<IBlockSection> m_section;
-        EngineMock m_engine;
-};
-
-TEST_F(IBlockSectionTest, Name)
-{
-    ASSERT_EQ(m_section->name(), "Test");
-}
-
-TEST_F(IBlockSectionTest, CategoryVisible)
-{
-    ASSERT_TRUE(m_section->categoryVisible());
-}
-
-TEST_F(IBlockSectionTest, RegisterBlocks)
-{
-    EXPECT_CALL(m_engine, addCompileFunction(m_section.get(), "", nullptr)).Times(1);
-    m_section->registerBlocks(&m_engine);
-}
diff --git a/test/extensions/iextension_test.cpp b/test/extensions/iextension_test.cpp
index 663553f4..2566730e 100644
--- a/test/extensions/iextension_test.cpp
+++ b/test/extensions/iextension_test.cpp
@@ -24,14 +24,14 @@ TEST_F(IExtensionTest, Description)
     ASSERT_EQ(m_extension->description(), "Test extension");
 }
 
-TEST_F(IExtensionTest, IncludeByDefault)
+TEST_F(IExtensionTest, RegisterBlocks)
 {
-    ASSERT_FALSE(m_extension->includeByDefault());
+    EXPECT_CALL(m_engine, clear);
+    m_extension->registerBlocks(&m_engine);
 }
 
-TEST_F(IExtensionTest, RegisterSections)
+TEST_F(IExtensionTest, OnInit)
 {
-    std::shared_ptr<IBlockSection> section = nullptr;
-    EXPECT_CALL(m_engine, registerSection(section)).Times(1);
-    m_extension->registerSections(&m_engine);
+    EXPECT_CALL(m_engine, clear);
+    m_extension->onInit(&m_engine);
 }
diff --git a/test/extensions/testextension.cpp b/test/extensions/testextension.cpp
index 20e3bb26..d7a8dd5b 100644
--- a/test/extensions/testextension.cpp
+++ b/test/extensions/testextension.cpp
@@ -14,12 +14,12 @@ std::string TestExtension::description() const
     return "Test extension";
 }
 
-bool TestExtension::includeByDefault() const
+void TestExtension::registerBlocks(IEngine *engine)
 {
-    return IExtension::includeByDefault();
+    engine->clear();
 }
 
-void TestExtension::registerSections(IEngine *engine)
+void TestExtension::onInit(IEngine *engine)
 {
-    engine->registerSection(nullptr);
+    engine->clear();
 }
diff --git a/test/extensions/testextension.h b/test/extensions/testextension.h
index 7237f9e8..7bad056d 100644
--- a/test/extensions/testextension.h
+++ b/test/extensions/testextension.h
@@ -11,9 +11,8 @@ class TestExtension : public IExtension
         std::string name() const override;
         std::string description() const override;
 
-        bool includeByDefault() const override;
-
-        void registerSections(IEngine *engine) override;
+        void registerBlocks(IEngine *engine) override;
+        void onInit(IEngine *engine) override;
 };
 
 } // namespace libscratchcpp
diff --git a/test/extensions/testsection.cpp b/test/extensions/testsection.cpp
deleted file mode 100644
index 6c7f6961..00000000
--- a/test/extensions/testsection.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <scratchcpp/iengine.h>
-
-#include "testsection.h"
-
-using namespace libscratchcpp;
-
-std::string TestSection::name() const
-{
-    return "Test";
-}
-
-bool TestSection::categoryVisible() const
-{
-    return IBlockSection::categoryVisible();
-}
-
-void TestSection::registerBlocks(IEngine *engine)
-{
-    engine->addCompileFunction(this, "", nullptr);
-}
diff --git a/test/extensions/testsection.h b/test/extensions/testsection.h
deleted file mode 100644
index 1ab69b00..00000000
--- a/test/extensions/testsection.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include <scratchcpp/iblocksection.h>
-
-namespace libscratchcpp
-{
-
-class TestSection : public IBlockSection
-{
-    public:
-        std::string name() const override;
-
-        bool categoryVisible() const override;
-
-        void registerBlocks(IEngine *engine) override;
-};
-
-} // namespace libscratchcpp
diff --git a/test/load_project/load_project_test.cpp b/test/load_project/load_project_test.cpp
index 1830b446..1a3fd10e 100644
--- a/test/load_project/load_project_test.cpp
+++ b/test/load_project/load_project_test.cpp
@@ -454,7 +454,7 @@ TEST(LoadProjectTest, LoadTestProject)
 
         // Monitors
         const auto &monitors = engine->monitors();
-        ASSERT_EQ(monitors.size(), 11);
+        ASSERT_EQ(monitors.size(), 10);
 
         // list1
         auto monitor = monitors[0];
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index deddb32f..d862de61 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -16,12 +16,12 @@ 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, (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(Thread *, startScript, (std::shared_ptr<Block>, Target *), (override));
+        MOCK_METHOD(void, broadcast, (int, Thread *, bool), (override));
+        MOCK_METHOD(void, broadcastByPtr, (Broadcast *, Thread *, bool), (override));
+        MOCK_METHOD(void, startBackdropScripts, (Broadcast *, Thread *, bool), (override));
+        MOCK_METHOD(void, stopScript, (Thread *), (override));
+        MOCK_METHOD(void, stopTarget, (Target *, Thread *), (override));
         MOCK_METHOD(void, initClone, (std::shared_ptr<Sprite>), (override));
         MOCK_METHOD(void, deinitClone, (std::shared_ptr<Sprite>), (override));
 
@@ -36,7 +36,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, stopEventLoop, (), (override));
 
         MOCK_METHOD(sigslot::signal<> &, aboutToRender, (), (override));
-        MOCK_METHOD(sigslot::signal<VirtualMachine *> &, threadAboutToStop, (), (override));
+        MOCK_METHOD(sigslot::signal<Thread *> &, threadAboutToStop, (), (override));
         MOCK_METHOD(sigslot::signal<> &, stopped, (), (override));
 
         MOCK_METHOD(bool, isRunning, (), (const, override));
@@ -80,25 +80,21 @@ class EngineMock : public IEngine
         MOCK_METHOD(bool, spriteFencingEnabled, (), (const, override));
         MOCK_METHOD(void, setSpriteFencingEnabled, (bool), (override));
 
-        MOCK_METHOD(bool, broadcastRunning, (unsigned int), (override));
-        MOCK_METHOD(bool, broadcastByPtrRunning, (Broadcast *), (override));
-
         MOCK_METHOD(void, requestRedraw, (), (override));
 
         MOCK_METHOD(ITimer *, timer, (), (const, override));
 
-        MOCK_METHOD(void, registerSection, (std::shared_ptr<IBlockSection>), (override));
         MOCK_METHOD(unsigned int, functionIndex, (BlockFunc), (override));
         MOCK_METHOD(const std::vector<BlockFunc> &, blockFunctions, (), (const, override));
 
-        MOCK_METHOD(void, addCompileFunction, (IBlockSection *, const std::string &, BlockComp), (override));
-        MOCK_METHOD(void, addHatPredicateCompileFunction, (IBlockSection *, const std::string &, HatPredicateCompileFunc), (override));
-        MOCK_METHOD(void, addMonitorNameFunction, (IBlockSection *, const std::string &, MonitorNameFunc), (override));
-        MOCK_METHOD(void, addMonitorChangeFunction, (IBlockSection *, const std::string &, MonitorChangeFunc), (override));
-        MOCK_METHOD(void, addHatBlock, (IBlockSection *, const std::string &), (override));
-        MOCK_METHOD(void, addInput, (IBlockSection *, const std::string &, int), (override));
-        MOCK_METHOD(void, addField, (IBlockSection *, const std::string &, int), (override));
-        MOCK_METHOD(void, addFieldValue, (IBlockSection *, const std::string &, int), (override));
+        MOCK_METHOD(void, addCompileFunction, (IExtension *, const std::string &, BlockComp), (override));
+        MOCK_METHOD(void, addHatPredicateCompileFunction, (IExtension *, const std::string &, HatPredicateCompileFunc), (override));
+        MOCK_METHOD(void, addMonitorNameFunction, (IExtension *, const std::string &, MonitorNameFunc), (override));
+        MOCK_METHOD(void, addMonitorChangeFunction, (IExtension *, const std::string &, MonitorChangeFunc), (override));
+        MOCK_METHOD(void, addHatBlock, (IExtension *, const std::string &), (override));
+        MOCK_METHOD(void, addInput, (IExtension *, const std::string &, int), (override));
+        MOCK_METHOD(void, addField, (IExtension *, const std::string &, int), (override));
+        MOCK_METHOD(void, addFieldValue, (IExtension *, const std::string &, int), (override));
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Broadcast>> &, broadcasts, (), (const, override));
         MOCK_METHOD(void, setBroadcasts, (const std::vector<std::shared_ptr<Broadcast>> &), (override));
@@ -108,28 +104,31 @@ class EngineMock : public IEngine
 
         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));
+        MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, Field *, Broadcast *), (override));
+        MOCK_METHOD(void, addBackdropChangeScript, (std::shared_ptr<Block>, Field *), (override));
         MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
-        MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, int), (override));
+        MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, Field *), (override));
         MOCK_METHOD(void, addTargetClickScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addWhenGreaterThanScript, (std::shared_ptr<Block>), (override));
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Target>> &, targets, (), (const, override));
         MOCK_METHOD(void, setTargets, (const std::vector<std::shared_ptr<Target>> &), (override));
         MOCK_METHOD(Target *, targetAt, (int), (const, override));
+        MOCK_METHOD(void, getVisibleTargets, (std::vector<Target *> &), (const, override));
         MOCK_METHOD(int, findTarget, (const std::string &), (const, override));
 
-        MOCK_METHOD(void, moveSpriteToFront, (Sprite * sprite), (override));
-        MOCK_METHOD(void, moveSpriteToBack, (Sprite * sprite), (override));
-        MOCK_METHOD(void, moveSpriteForwardLayers, (Sprite * sprite, int layers), (override));
-        MOCK_METHOD(void, moveSpriteBackwardLayers, (Sprite * sprite, int layers), (override));
-        MOCK_METHOD(void, moveSpriteBehindOther, (Sprite * sprite, Sprite *other), (override));
+        MOCK_METHOD(void, moveDrawableToFront, (Drawable *), (override));
+        MOCK_METHOD(void, moveDrawableToBack, (Drawable *), (override));
+        MOCK_METHOD(void, moveDrawableForwardLayers, (Drawable *, int), (override));
+        MOCK_METHOD(void, moveDrawableBackwardLayers, (Drawable *, int), (override));
+        MOCK_METHOD(void, moveDrawableBehindOther, (Drawable *, Drawable *), (override));
 
         MOCK_METHOD(Stage *, stage, (), (const, override));
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Monitor>> &, monitors, (), (const, override));
         MOCK_METHOD(void, setMonitors, (const std::vector<std::shared_ptr<Monitor>> &), (override));
+        MOCK_METHOD(Monitor *, createVariableMonitor, (std::shared_ptr<Variable>, const std::string &, const std::string &, int, BlockComp), (override));
+        MOCK_METHOD(Monitor *, createListMonitor, (std::shared_ptr<List>, const std::string &, const std::string &, int, BlockComp), (override));
         MOCK_METHOD(sigslot::signal<Monitor *> &, monitorAdded, (), (override));
         MOCK_METHOD((sigslot::signal<Monitor *, IMonitorHandler *> &), monitorRemoved, (), (override));
 
diff --git a/test/mocks/blocksectionmock.h b/test/mocks/extensionmock.h
similarity index 65%
rename from test/mocks/blocksectionmock.h
rename to test/mocks/extensionmock.h
index 5050d83c..19f47d6e 100644
--- a/test/mocks/blocksectionmock.h
+++ b/test/mocks/extensionmock.h
@@ -1,15 +1,15 @@
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 #include <gmock/gmock.h>
 
 using namespace libscratchcpp;
 
-class BlockSectionMock : public IBlockSection
+class ExtensionMock : public IExtension
 {
     public:
         MOCK_METHOD(std::string, name, (), (const, override));
-        MOCK_METHOD(bool, categoryVisible, (), (const, override));
+        MOCK_METHOD(std::string, description, (), (const, override));
 
         MOCK_METHOD(void, registerBlocks, (IEngine *), (override));
         MOCK_METHOD(void, onInit, (IEngine *), (override));
diff --git a/test/mocks/graphicseffectmock.h b/test/mocks/graphicseffectmock.h
index 49500ac2..7ddc71ce 100644
--- a/test/mocks/graphicseffectmock.h
+++ b/test/mocks/graphicseffectmock.h
@@ -9,4 +9,6 @@ class GraphicsEffectMock : public IGraphicsEffect
 {
     public:
         MOCK_METHOD(std::string, name, (), (const, override));
+
+        MOCK_METHOD(double, clamp, (double), (const, override));
 };
diff --git a/test/mocks/monitorhandlermock.h b/test/mocks/monitorhandlermock.h
index 2c4aa673..88f9e142 100644
--- a/test/mocks/monitorhandlermock.h
+++ b/test/mocks/monitorhandlermock.h
@@ -11,5 +11,7 @@ class MonitorHandlerMock : public IMonitorHandler
         MOCK_METHOD(void, init, (Monitor *), (override));
 
         MOCK_METHOD(void, onValueChanged, (const VirtualMachine *), (override));
+        MOCK_METHOD(void, onXChanged, (int), (override));
+        MOCK_METHOD(void, onYChanged, (int), (override));
         MOCK_METHOD(void, onVisibleChanged, (bool), (override));
 };
diff --git a/test/mocks/spritehandlermock.h b/test/mocks/spritehandlermock.h
index d944f807..a3d2ab4b 100644
--- a/test/mocks/spritehandlermock.h
+++ b/test/mocks/spritehandlermock.h
@@ -26,8 +26,6 @@ class SpriteHandlerMock : public ISpriteHandler
         MOCK_METHOD(void, onLayerOrderChanged, (int), (override));
         MOCK_METHOD(void, onGraphicsEffectChanged, (IGraphicsEffect *, double), (override));
         MOCK_METHOD(void, onGraphicsEffectsCleared, (), (override));
-        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));
@@ -38,4 +36,5 @@ class SpriteHandlerMock : public ISpriteHandler
         MOCK_METHOD(bool, touchingClones, (const std::vector<Sprite *> &), (const, override));
         MOCK_METHOD(bool, touchingPoint, (double, double), (const, override));
         MOCK_METHOD(bool, touchingColor, (const Value &), (const, override));
+        MOCK_METHOD(bool, touchingColor, (const Value &, const Value &), (const, override));
 };
diff --git a/test/mocks/stagehandlermock.h b/test/mocks/stagehandlermock.h
index a7e15055..9e3892ed 100644
--- a/test/mocks/stagehandlermock.h
+++ b/test/mocks/stagehandlermock.h
@@ -17,8 +17,6 @@ class StageHandlerMock : public IStageHandler
         MOCK_METHOD(void, onVideoTransparencyChanged, (int), (override));
         MOCK_METHOD(void, onGraphicsEffectChanged, (IGraphicsEffect *, double), (override));
         MOCK_METHOD(void, onGraphicsEffectsCleared, (), (override));
-        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));
@@ -29,4 +27,5 @@ class StageHandlerMock : public IStageHandler
         MOCK_METHOD(bool, touchingClones, (const std::vector<Sprite *> &), (const, override));
         MOCK_METHOD(bool, touchingPoint, (double, double), (const, override));
         MOCK_METHOD(bool, touchingColor, (const Value &), (const, override));
+        MOCK_METHOD(bool, touchingColor, (const Value &, const Value &), (const, override));
 };
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
index 5df18e09..aca1c4c6 100644
--- a/test/mocks/targetmock.h
+++ b/test/mocks/targetmock.h
@@ -28,13 +28,11 @@ class TargetMock : public Target
         MOCK_METHOD(bool, touchingPoint, (double, double), (const, override));
 
         MOCK_METHOD(bool, touchingColor, (const Value &), (const, override));
+        MOCK_METHOD(bool, touchingColor, (const Value &, const Value &), (const, override));
 
         MOCK_METHOD(void, setGraphicsEffectValue, (IGraphicsEffect *, double), (override));
         MOCK_METHOD(void, clearGraphicsEffects, (), (override));
 
-        MOCK_METHOD(void, setBubbleType, (BubbleType), (override));
-        MOCK_METHOD(void, setBubbleText, (const std::string &), (override));
-
         MOCK_METHOD(Target *, dataSource, (), (const, override));
 
         Target *dataSourceBase() const { return Target::dataSource(); };
diff --git a/test/rect/rect_test.cpp b/test/rect/rect_test.cpp
index ec1abe8b..fb4dd437 100644
--- a/test/rect/rect_test.cpp
+++ b/test/rect/rect_test.cpp
@@ -78,6 +78,27 @@ TEST(RectTest, Height)
     ASSERT_EQ(rect.height(), 35.272);
 }
 
+TEST(RectTest, SnapToInt)
+{
+    {
+        Rect rect(20.5, 12.5, 22.5, 8.5);
+        rect.snapToInt();
+        ASSERT_EQ(rect.left(), 20);
+        ASSERT_EQ(rect.top(), 13);
+        ASSERT_EQ(rect.right(), 23);
+        ASSERT_EQ(rect.bottom(), 8);
+    }
+
+    {
+        Rect rect(20.5, 12.2, 22.3, 8.5);
+        rect.snapToInt();
+        ASSERT_EQ(rect.left(), 20);
+        ASSERT_EQ(rect.top(), 13);
+        ASSERT_EQ(rect.right(), 23);
+        ASSERT_EQ(rect.bottom(), 8);
+    }
+}
+
 TEST(RectTest, Intersects)
 {
     Rect rect1(-50, 25, 150, -75);
diff --git a/test/regtest_projects/563_broadcast_stops_wait_blocks.sb3 b/test/regtest_projects/563_broadcast_stops_wait_blocks.sb3
new file mode 100644
index 00000000..09872331
Binary files /dev/null and b/test/regtest_projects/563_broadcast_stops_wait_blocks.sb3 differ
diff --git a/test/scratch_classes/CMakeLists.txt b/test/scratch_classes/CMakeLists.txt
index f7ab3cfd..279727bb 100644
--- a/test/scratch_classes/CMakeLists.txt
+++ b/test/scratch_classes/CMakeLists.txt
@@ -26,6 +26,22 @@ target_link_libraries(
 
 gtest_discover_tests(list_test)
 
+# drawable_test
+add_executable(
+  drawable_test
+  drawable_test.cpp
+)
+
+target_link_libraries(
+  drawable_test
+  GTest::gtest_main
+  GTest::gmock_main
+  scratchcpp
+  scratchcpp_mocks
+)
+
+gtest_discover_tests(drawable_test)
+
 # sprite_test
 add_executable(
   sprite_test
@@ -74,6 +90,22 @@ target_link_libraries(
 
 gtest_discover_tests(target_test)
 
+# textbubble_test
+add_executable(
+  textbubble_test
+  textbubble_test.cpp
+)
+
+target_link_libraries(
+  textbubble_test
+  GTest::gmock_main
+  scratchcpp
+  scratchcpp_mocks
+  scratchcpp
+)
+
+gtest_discover_tests(textbubble_test)
+
 # value_test
 add_executable(
   value_test
@@ -222,8 +254,8 @@ gtest_discover_tests(comment_test)
 add_executable(
   monitor_test
   monitor_test.cpp
-  testsection.cpp
-  testsection.h
+  testextension.cpp
+  testextension.h
 )
 
 target_link_libraries(
diff --git a/test/scratch_classes/drawable_test.cpp b/test/scratch_classes/drawable_test.cpp
new file mode 100644
index 00000000..b8a80670
--- /dev/null
+++ b/test/scratch_classes/drawable_test.cpp
@@ -0,0 +1,36 @@
+#include <scratchcpp/drawable.h>
+#include <enginemock.h>
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(DrawableTest, IsTarget)
+{
+    Drawable drawable;
+    ASSERT_FALSE(drawable.isTarget());
+}
+
+TEST(DrawableTest, IsTextBubble)
+{
+    Drawable drawable;
+    ASSERT_FALSE(drawable.isTextBubble());
+}
+
+TEST(DrawableTest, LayerOrder)
+{
+    Drawable drawable;
+    ASSERT_EQ(drawable.layerOrder(), 0);
+    drawable.setLayerOrder(2);
+    ASSERT_EQ(drawable.layerOrder(), 2);
+}
+
+TEST(TargetTest, Engine)
+{
+    Drawable drawable;
+    ASSERT_EQ(drawable.engine(), nullptr);
+
+    EngineMock engine;
+    drawable.setEngine(&engine);
+    ASSERT_EQ(drawable.engine(), &engine);
+}
diff --git a/test/scratch_classes/list_test.cpp b/test/scratch_classes/list_test.cpp
index 2c01ec9a..a6574b5d 100644
--- a/test/scratch_classes/list_test.cpp
+++ b/test/scratch_classes/list_test.cpp
@@ -40,71 +40,125 @@ TEST(ListTest, Monitor)
     ASSERT_EQ(list.monitor(), &monitor);
 }
 
+TEST(ListTest, Size)
+{
+    List list("", "test list");
+    ASSERT_EQ(list.size(), 0);
+    ASSERT_TRUE(list.empty());
+
+    list.append("Lorem");
+    list.append("ipsum");
+    ASSERT_EQ(list.size(), 2);
+    ASSERT_FALSE(list.empty());
+
+    list.append("dolor");
+    ASSERT_EQ(list.size(), 3);
+    ASSERT_FALSE(list.empty());
+
+    list.removeAt(0);
+    ASSERT_EQ(list.size(), 2);
+    ASSERT_FALSE(list.empty());
+}
+
 TEST(ListTest, IndexOf)
 {
     List list("", "test list");
-    list.push_back("Lorem");
-    list.push_back("ipsum");
-    list.push_back("dolor");
-    list.push_back("sit");
-    list.push_back("amet");
-    list.push_back("é čľíá");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+    list.append("é čľíá");
 
     ASSERT_EQ(list.indexOf(""), -1);
     ASSERT_EQ(list.indexOf("test"), -1);
     ASSERT_EQ(list.indexOf("Lorem"), 0);
     ASSERT_EQ(list.indexOf("ipsum"), 1);
-    ASSERT_EQ(list.indexOf("iPsum"), 1);
-    ASSERT_EQ(list.indexOf("dolor"), 2);
+    ASSERT_EQ(list.indexOf(Value("iPsum").data()), 1);
+    ASSERT_EQ(list.indexOf(Value("dolor").data()), 2);
     ASSERT_EQ(list.indexOf("sit"), 3);
     ASSERT_EQ(list.indexOf("amet"), 4);
     ASSERT_EQ(list.indexOf("é čľíá"), 5);
 
     list.clear();
-    list.push_back("");
+    list.append("");
     ASSERT_EQ(list.indexOf(""), 0);
 }
 
 TEST(ListTest, Contains)
 {
     List list("", "test list");
-    list.push_back("Lorem");
-    list.push_back("ipsum");
-    list.push_back("dolor");
-    list.push_back("sit");
-    list.push_back("amet");
-    list.push_back("é čľíá");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+    list.append("é čľíá");
 
     ASSERT_FALSE(list.contains(""));
+    ASSERT_FALSE(list.contains(Value("test").data()));
     ASSERT_FALSE(list.contains("test"));
     ASSERT_TRUE(list.contains("Lorem"));
     ASSERT_TRUE(list.contains("ipsum"));
     ASSERT_TRUE(list.contains("iPsum"));
     ASSERT_TRUE(list.contains("dolor"));
-    ASSERT_TRUE(list.contains("sit"));
+    ASSERT_TRUE(list.contains(Value("sit").data()));
     ASSERT_TRUE(list.contains("amet"));
     ASSERT_TRUE(list.contains("é čľíá"));
 
     list.clear();
-    list.push_back("");
+    list.append("");
     ASSERT_TRUE(list.contains(""));
 }
 
+TEST(ListTest, Clear)
+{
+    List list("", "test list");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+    list.append("é čľíá");
+
+    list.clear();
+    ASSERT_EQ(list.size(), 0);
+    ASSERT_TRUE(list.empty());
+}
+
+TEST(ListTest, Append)
+{
+    List list("", "test list");
+    list.append("Lorem");
+    list.append(Value("ipsum").data());
+    list.append("dolor");
+    list.append(Value("sit").data());
+    list.append("amet");
+    ASSERT_EQ(list.toString(), "Lorem ipsum dolor sit amet");
+
+    list.append("consectetur");
+    ASSERT_EQ(list.toString(), "Lorem ipsum dolor sit amet consectetur");
+
+    list.clear();
+    list.append("adipiscing");
+    ASSERT_EQ(list.toString(), "adipiscing");
+}
+
 TEST(ListTest, RemoveAt)
 {
     List list("", "test list");
-    list.push_back("Lorem");
-    list.push_back("ipsum");
-    list.push_back("dolor");
-    list.push_back("sit");
-    list.push_back("amet");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
     list.removeAt(1);
     ASSERT_EQ(list.toString(), "Lorem dolor sit amet");
     list.removeAt(3);
     ASSERT_EQ(list.toString(), "Lorem dolor sit");
     list.removeAt(0);
     ASSERT_EQ(list.toString(), "dolor sit");
-    list.removeAt(3);
+    list.removeAt(1);
     ASSERT_EQ(list.toString(), "dolor");
     list.removeAt(0);
     ASSERT_TRUE(list.empty());
@@ -113,13 +167,13 @@ TEST(ListTest, RemoveAt)
 TEST(ListTest, Insert)
 {
     List list("", "test list");
-    list.insert(0, "Lorem");
+    list.insert(0, Value("Lorem").data());
     list.insert(0, "ipsum");
     list.insert(0, "dolor");
     ASSERT_EQ(list.toString(), "dolor ipsum Lorem");
     list.insert(1, "sit");
     ASSERT_EQ(list.toString(), "dolor sit ipsum Lorem");
-    list.insert(2, "amet");
+    list.insert(2, Value("amet").data());
     ASSERT_EQ(list.toString(), "dolor sit amet ipsum Lorem");
     list.insert(5, "consectetur");
     ASSERT_EQ(list.toString(), "dolor sit amet ipsum Lorem consectetur");
@@ -130,77 +184,110 @@ TEST(ListTest, Insert)
 TEST(ListTest, Replace)
 {
     List list("", "test list");
-    list.push_back("Lorem");
-    list.push_back("ipsum");
-    list.push_back("dolor");
-    list.push_back("sit");
-    list.push_back("amet");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
     ASSERT_EQ(list.toString(), "Lorem ipsum dolor sit amet");
     list.replace(0, "test1");
     ASSERT_EQ(list.toString(), "test1 ipsum dolor sit amet");
-    list.replace(4, "test2");
+    list.replace(4, Value("test2").data());
     ASSERT_EQ(list.toString(), "test1 ipsum dolor sit test2");
-    list.replace(2, "test3");
+    list.replace(2, Value("test3").data());
     ASSERT_EQ(list.toString(), "test1 ipsum test3 sit test2");
 }
 
+TEST(ListTest, ArrayIndexOperator)
+{
+    List list("", "test list");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
+
+    ASSERT_EQ(Value(list[0]).toString(), "Lorem");
+    ASSERT_EQ(Value(list[1]).toString(), "ipsum");
+    ASSERT_EQ(Value(list[2]).toString(), "dolor");
+    ASSERT_EQ(Value(list[3]).toString(), "sit");
+    ASSERT_EQ(Value(list[4]).toString(), "amet");
+}
+
 TEST(ListTest, ToString)
 {
     List list("", "test list");
+    std::string s;
+    list.toString(s);
+    ASSERT_EQ(s, "");
     ASSERT_EQ(list.toString(), "");
 
-    list.push_back("");
+    list.append("");
+    list.toString(s);
+    ASSERT_EQ(s, "");
     ASSERT_EQ(list.toString(), "");
 
-    list.push_back("");
-    list.push_back("");
+    list.append("");
+    list.append("");
     ASSERT_EQ(list.toString(), "  ");
 
     list.clear();
-    list.push_back("item1");
-    list.push_back("i t e m 2");
-    list.push_back("item 3");
+    list.append("item1");
+    list.append("i t e m 2");
+    list.append("item 3");
+    list.toString(s);
+    ASSERT_EQ(s, "item1 i t e m 2 item 3");
     ASSERT_EQ(list.toString(), "item1 i t e m 2 item 3");
 
     list.clear();
-    list.push_back(" ");
-    list.push_back("a ");
-    list.push_back(" b");
-    list.push_back(" c ");
+    list.append(" ");
+    list.append("a ");
+    list.append(" b");
+    list.append(" c ");
+    list.toString(s);
+    ASSERT_EQ(s, "  a   b  c ");
     ASSERT_EQ(list.toString(), "  a   b  c ");
 
     list.clear();
-    list.push_back("áä");
-    list.push_back("ľ š");
+    list.append("áä");
+    list.append("ľ š");
+    list.toString(s);
+    ASSERT_EQ(s, "áä ľ š");
     ASSERT_EQ(list.toString(), "áä ľ š");
 
     list.clear();
-    list.push_back(-2);
-    list.push_back(5);
-    list.push_back(8);
+    list.append(-2);
+    list.append(5);
+    list.append(8);
+    list.toString(s);
+    ASSERT_EQ(s, "-2 5 8");
     ASSERT_EQ(list.toString(), "-2 5 8");
 
     list.clear();
-    list.push_back(2);
-    list.push_back(10);
-    list.push_back(8);
+    list.append(2);
+    list.append(10);
+    list.append(8);
+    list.toString(s);
+    ASSERT_EQ(s, "2 10 8");
     ASSERT_EQ(list.toString(), "2 10 8");
 
     list.clear();
-    list.push_back(0);
-    list.push_back(9);
-    list.push_back(8);
+    list.append(0);
+    list.append(9);
+    list.append(8);
+    list.toString(s);
+    ASSERT_EQ(s, "098");
     ASSERT_EQ(list.toString(), "098");
 }
 
 TEST(ListTest, Clone)
 {
     List list("abc", "test list");
-    list.push_back("Lorem");
-    list.push_back("ipsum");
-    list.push_back("dolor");
-    list.push_back("sit");
-    list.push_back("amet");
+    list.append("Lorem");
+    list.append("ipsum");
+    list.append("dolor");
+    list.append("sit");
+    list.append("amet");
 
     std::shared_ptr<List> clone = list.clone();
     ASSERT_TRUE(clone);
@@ -209,5 +296,5 @@ TEST(ListTest, Clone)
     ASSERT_EQ(clone->size(), list.size());
 
     for (std::size_t i = 0; i < list.size(); i++)
-        ASSERT_EQ(list[i], (*clone)[i]);
+        ASSERT_TRUE(value_equals(&list[i], &(*clone)[i]));
 }
diff --git a/test/scratch_classes/monitor_test.cpp b/test/scratch_classes/monitor_test.cpp
index 618811ad..4080703e 100644
--- a/test/scratch_classes/monitor_test.cpp
+++ b/test/scratch_classes/monitor_test.cpp
@@ -4,12 +4,11 @@
 #include <scratchcpp/rect.h>
 #include <scratchcpp/virtualmachine.h>
 #include <scratchcpp/script.h>
-#include <scratch/monitor_p.h>
 #include <monitorhandlermock.h>
 #include <randomgeneratormock.h>
 
 #include "../common.h"
-#include "testsection.h"
+#include "testextension.h"
 
 using namespace libscratchcpp;
 
@@ -20,7 +19,6 @@ using ::testing::_;
 static const int PADDING = 5;
 static const int SCREEN_WIDTH = 400;
 static const int SCREEN_HEIGHT = 300;
-static const int SCREEN_EDGE_BUFFER = 40;
 
 TEST(MonitorTest, Constructors)
 {
@@ -29,6 +27,7 @@ TEST(MonitorTest, Constructors)
     ASSERT_EQ(monitor.opcode(), "test");
     ASSERT_TRUE(monitor.block());
     ASSERT_EQ(monitor.block()->opcode(), "test");
+    ASSERT_TRUE(monitor.needsAutoPosition());
 }
 
 TEST(MonitorTest, Id)
@@ -85,14 +84,14 @@ TEST(MonitorTest, Script)
     ASSERT_EQ(monitor.script(), script);
 }
 
-TEST(MonitorTest, BlockSection)
+TEST(MonitorTest, Extension)
 {
     Monitor monitor("", "");
-    ASSERT_EQ(monitor.blockSection(), nullptr);
+    ASSERT_EQ(monitor.extension(), nullptr);
 
-    auto section = std::make_shared<TestSection>();
-    monitor.setBlockSection(section);
-    ASSERT_EQ(monitor.blockSection(), section);
+    auto extension = std::make_shared<TestExtension>();
+    monitor.setExtension(extension.get());
+    ASSERT_EQ(monitor.extension(), extension.get());
 }
 
 TEST(MonitorTest, Sprite)
@@ -182,8 +181,14 @@ TEST(MonitorTest, X)
     Monitor monitor("", "");
     ASSERT_EQ(monitor.x(), 0);
 
+    MonitorHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    monitor.setInterface(&handler);
+
+    EXPECT_CALL(handler, onXChanged(-78));
     monitor.setX(-78);
     ASSERT_EQ(monitor.x(), -78);
+    ASSERT_FALSE(monitor.needsAutoPosition());
 }
 
 TEST(MonitorTest, Y)
@@ -191,8 +196,14 @@ TEST(MonitorTest, Y)
     Monitor monitor("", "");
     ASSERT_EQ(monitor.y(), 0);
 
+    MonitorHandlerMock handler;
+    EXPECT_CALL(handler, init);
+    monitor.setInterface(&handler);
+
+    EXPECT_CALL(handler, onYChanged(150));
     monitor.setY(150);
     ASSERT_EQ(monitor.y(), 150);
+    ASSERT_FALSE(monitor.needsAutoPosition());
 }
 
 TEST(MonitorTest, Visible)
@@ -259,36 +270,103 @@ TEST(MonitorTest, Discrete)
     ASSERT_FALSE(monitor.discrete());
 }
 
-TEST(MonitorTest, GetInitialPosition)
+TEST(MonitorTest, AutoPosition_LineUpTopLeft)
 {
-    std::vector<std::shared_ptr<Monitor>> monitors;
+    // https://github.com/scratchfoundation/scratch-gui/blob/875bee35f178411b9149ab766d17b5fb88ddd749/test/unit/reducers/monitor-layout-reducer.test.js#L216-L238
     const int width = 100;
     const int height = 200;
 
-    auto monitor1 = std::make_shared<Monitor>("", "");
-    monitor1->setWidth(PADDING);
-    monitor1->setHeight(height);
-    monitor1->setX(100);
-    monitor1->setY(0);
-    monitors.push_back(monitor1);
-
-    auto monitor2 = std::make_shared<Monitor>("", "");
-    monitor2->setWidth(width);
-    monitor2->setHeight(height + PADDING - 100);
-    monitor2->setX(0);
-    monitor2->setY(100);
-    monitors.push_back(monitor2);
-
-    RandomGeneratorMock rng;
-    MonitorPrivate::rng = &rng;
-
-    EXPECT_CALL(rng, randintDouble(0, SCREEN_WIDTH / 2.0)).WillOnce(Return(SCREEN_WIDTH / 4.5));
-    EXPECT_CALL(rng, randintDouble(0, SCREEN_HEIGHT - SCREEN_EDGE_BUFFER)).WillOnce(Return(SCREEN_HEIGHT - SCREEN_EDGE_BUFFER * 2.3));
-    Rect rect = Monitor::getInitialPosition(monitors, width, height);
-    ASSERT_EQ(rect.left(), std::ceil(SCREEN_WIDTH / 4.5));
-    ASSERT_EQ(rect.top(), std::ceil(SCREEN_HEIGHT - SCREEN_EDGE_BUFFER * 2.3));
-    ASSERT_EQ(rect.width(), width);
-    ASSERT_EQ(rect.height(), height);
-
-    MonitorPrivate::rng = nullptr;
+    auto monitor = std::make_shared<Monitor>("", "");
+    monitor->setWidth(width);
+    monitor->setHeight(height);
+
+    // Add monitors to right and bottom, but there is a space in the top left
+    std::vector<std::shared_ptr<Monitor>> monitors = { std::make_shared<Monitor>("", ""), std::make_shared<Monitor>("", ""), monitor };
+
+    monitors[0]->setX(width + 2 * PADDING);
+    monitors[0]->setY(0);
+    monitors[0]->setWidth(100);
+    monitors[0]->setHeight(height);
+
+    monitors[1]->setX(0);
+    monitors[1]->setY(height + 2 * PADDING);
+    monitors[1]->setWidth(width);
+    monitors[1]->setHeight(100);
+
+    // Check that the added monitor appears in the space
+    monitor->autoPosition(monitors);
+    ASSERT_EQ(monitor->width(), width);
+    ASSERT_EQ(monitor->height(), height);
+    ASSERT_EQ(monitor->x(), PADDING);
+    ASSERT_EQ(monitor->y(), PADDING);
+    ASSERT_FALSE(monitor->needsAutoPosition());
+}
+
+TEST(MonitorTest, AutoPosition_LineUpLeft)
+{
+    // https://github.com/scratchfoundation/scratch-gui/blob/875bee35f178411b9149ab766d17b5fb88ddd749/test/unit/reducers/monitor-layout-reducer.test.js#L261-L270
+    auto monitor = std::make_shared<Monitor>("", "");
+    monitor->setWidth(20);
+    monitor->setHeight(20);
+
+    const int monitor1EndY = 60;
+
+    // Add a monitor that takes up the upper left corner
+    std::vector<std::shared_ptr<Monitor>> monitors = { std::make_shared<Monitor>("", ""), monitor };
+    monitors[0]->setX(0);
+    monitors[0]->setY(0);
+    monitors[0]->setWidth(100);
+    monitors[0]->setHeight(monitor1EndY);
+
+    // Check that added monitor is under it and lines up left
+    monitor->autoPosition(monitors);
+    ASSERT_EQ(monitor->width(), 20);
+    ASSERT_EQ(monitor->height(), 20);
+    ASSERT_GE(monitor->y(), monitor1EndY + PADDING);
+    ASSERT_FALSE(monitor->needsAutoPosition());
+}
+
+TEST(MonitorTest, LineUpTop)
+{
+    // https://github.com/scratchfoundation/scratch-gui/blob/875bee35f178411b9149ab766d17b5fb88ddd749/test/unit/reducers/monitor-layout-reducer.test.js#L272-L285
+    auto monitor = std::make_shared<Monitor>("", "");
+    monitor->setWidth(20);
+    monitor->setHeight(20);
+
+    const int monitor1EndX = 100;
+
+    // Add a monitor that takes up the whole left side
+    std::vector<std::shared_ptr<Monitor>> monitors = { std::make_shared<Monitor>("", ""), monitor };
+    monitors[0]->setX(0);
+    monitors[0]->setY(0);
+    monitors[0]->setWidth(monitor1EndX);
+    monitors[0]->setHeight(SCREEN_HEIGHT);
+
+    // Check that added monitor is to the right of it and lines up top
+    monitor->autoPosition(monitors);
+    ASSERT_EQ(monitor->width(), 20);
+    ASSERT_EQ(monitor->height(), 20);
+    ASSERT_EQ(monitor->y(), PADDING);
+    ASSERT_GE(monitor->x(), monitor1EndX + PADDING);
+}
+
+TEST(MonitorTest, AutoPosition_NoRoom)
+{
+    // https://github.com/scratchfoundation/scratch-gui/blob/875bee35f178411b9149ab766d17b5fb88ddd749/test/unit/reducers/monitor-layout-reducer.test.js#L287-L302
+    auto monitor = std::make_shared<Monitor>("", "");
+    monitor->setWidth(7);
+    monitor->setHeight(8);
+
+    // Add a monitor that takes up the whole screen
+    std::vector<std::shared_ptr<Monitor>> monitors = { std::make_shared<Monitor>("", ""), monitor };
+    monitors[0]->setX(0);
+    monitors[0]->setY(0);
+    monitors[0]->setWidth(SCREEN_WIDTH);
+    monitors[0]->setHeight(SCREEN_HEIGHT);
+
+    // Check that added monitor exists somewhere (we don't care where)
+    monitor->autoPosition(monitors);
+    ASSERT_EQ(monitor->width(), 7);
+    ASSERT_EQ(monitor->height(), 8);
+    ASSERT_FALSE(monitor->needsAutoPosition());
 }
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index ea79c577..572bd5f5 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -1,5 +1,6 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
+#include <scratchcpp/textbubble.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/costume.h>
@@ -72,10 +73,10 @@ TEST(SpriteTest, Clone)
     sprite.addSound(s3);
 
     auto list1 = std::make_shared<List>("c", "list1");
-    list1->push_back("item1");
-    list1->push_back("item2");
+    list1->append("item1");
+    list1->append("item2");
     auto list2 = std::make_shared<List>("d", "list2");
-    list2->push_back("test");
+    list2->append("test");
     sprite.addList(list1);
     sprite.addList(list2);
 
@@ -112,10 +113,12 @@ TEST(SpriteTest, Clone)
         ASSERT_NE(clone->lists(), root->lists());
         ASSERT_EQ(clone->listAt(0)->id(), "c");
         ASSERT_EQ(clone->listAt(0)->name(), "list1");
-        ASSERT_EQ(*clone->listAt(0), std::deque<Value>({ "item1", "item2" }));
+        ASSERT_EQ(clone->listAt(0)->size(), 2);
+        ASSERT_EQ(clone->listAt(0)->toString(), "item1 item2");
         ASSERT_EQ(clone->listAt(1)->id(), "d");
         ASSERT_EQ(clone->listAt(1)->name(), "list2");
-        ASSERT_EQ(*clone->listAt(1), std::deque<Value>({ "test" }));
+        ASSERT_EQ(clone->listAt(1)->size(), 1);
+        ASSERT_EQ(clone->listAt(1)->toString(), "test");
         ASSERT_EQ(clone->listAt(1)->target(), clone);
 
         ASSERT_EQ(clone->sounds().size(), 3);
@@ -153,10 +156,10 @@ TEST(SpriteTest, Clone)
     EXPECT_CALL(engine, cloneLimit()).Times(6).WillRepeatedly(Return(300)); // clone count limit is tested later
 
     std::shared_ptr<Sprite> clone1;
-    Sprite *clone1_2;
+    Drawable *clone1_2;
     EXPECT_CALL(engine, cloneCount()).WillOnce(Return(0));
     EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone1));
-    EXPECT_CALL(engine, moveSpriteBehindOther(_, &sprite)).WillOnce(SaveArg<0>(&clone1_2));
+    EXPECT_CALL(engine, moveDrawableBehindOther(_, &sprite)).WillOnce(SaveArg<0>(&clone1_2));
     ASSERT_EQ(sprite.clone(), clone1);
     ASSERT_EQ(clone1.get(), clone1_2);
     ASSERT_FALSE(sprite.isClone());
@@ -171,10 +174,10 @@ TEST(SpriteTest, Clone)
     sprite.setLayerOrder(3);
 
     std::shared_ptr<Sprite> clone2;
-    Sprite *clone2_2;
+    Drawable *clone2_2;
     EXPECT_CALL(engine, cloneCount()).WillOnce(Return(1));
     EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone2));
-    EXPECT_CALL(engine, moveSpriteBehindOther(_, clone1.get())).WillOnce(SaveArg<0>(&clone2_2));
+    EXPECT_CALL(engine, moveDrawableBehindOther(_, clone1.get())).WillOnce(SaveArg<0>(&clone2_2));
     ASSERT_EQ(clone1->clone(), clone2);
     ASSERT_EQ(clone2.get(), clone2_2);
     ASSERT_TRUE(clone1->isClone());
@@ -187,18 +190,18 @@ TEST(SpriteTest, Clone)
     sprite.setVisible(true);
 
     std::shared_ptr<Sprite> clone3;
-    Sprite *clone3_2;
+    Drawable *clone3_2;
     EXPECT_CALL(engine, cloneCount()).WillOnce(Return(2));
     EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone3));
-    EXPECT_CALL(engine, moveSpriteBehindOther(_, clone1.get())).WillOnce(SaveArg<0>(&clone3_2));
+    EXPECT_CALL(engine, moveDrawableBehindOther(_, clone1.get())).WillOnce(SaveArg<0>(&clone3_2));
     ASSERT_EQ(clone1->clone(), clone3);
     ASSERT_EQ(clone3.get(), clone3_2);
 
     std::shared_ptr<Sprite> clone4;
-    Sprite *clone4_2;
+    Drawable *clone4_2;
     EXPECT_CALL(engine, cloneLimit()).WillOnce(Return(-1));
     EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone4));
-    EXPECT_CALL(engine, moveSpriteBehindOther(_, &sprite)).WillOnce(SaveArg<0>(&clone4_2));
+    EXPECT_CALL(engine, moveDrawableBehindOther(_, &sprite)).WillOnce(SaveArg<0>(&clone4_2));
     ASSERT_EQ(sprite.clone(), clone4);
     ASSERT_EQ(clone4.get(), clone4_2);
 
@@ -405,7 +408,7 @@ TEST(SpriteTest, Dragging)
     EXPECT_CALL(engine, spriteFencingEnabled).WillRepeatedly(Return(false));
     EXPECT_CALL(engine, requestRedraw).WillRepeatedly(Return());
 
-    EXPECT_CALL(engine, moveSpriteToFront(&sprite));
+    EXPECT_CALL(engine, moveDrawableToFront(&sprite));
     sprite.startDragging();
     ASSERT_TRUE(sprite.dragging());
 
@@ -751,7 +754,7 @@ TEST(SpriteTest, TouchingSprite)
     EXPECT_CALL(engine, cloneLimit()).WillRepeatedly(Return(-1));
     EXPECT_CALL(engine, initClone).Times(3);
     EXPECT_CALL(engine, requestRedraw).Times(3);
-    EXPECT_CALL(engine, moveSpriteBehindOther).Times(3);
+    EXPECT_CALL(engine, moveDrawableBehindOther).Times(3);
     auto clone1 = another.clone();
     auto clone2 = another.clone();
     auto clone3 = another.clone();
@@ -825,6 +828,7 @@ TEST(SpriteTest, TouchingColor)
 {
     Sprite sprite;
     ASSERT_FALSE(sprite.touchingColor(0));
+    ASSERT_FALSE(sprite.touchingColor(0, 0));
 
     SpriteHandlerMock iface;
     EXPECT_CALL(iface, init);
@@ -836,6 +840,12 @@ TEST(SpriteTest, TouchingColor)
 
     EXPECT_CALL(iface, touchingColor(v2)).WillOnce(Return(true));
     ASSERT_TRUE(sprite.touchingColor(v2));
+
+    EXPECT_CALL(iface, touchingColor(v1, v2)).WillOnce(Return(false));
+    ASSERT_FALSE(sprite.touchingColor(v1, v2));
+
+    EXPECT_CALL(iface, touchingColor(v2, v1)).WillOnce(Return(true));
+    ASSERT_TRUE(sprite.touchingColor(v2, v1));
 }
 
 TEST(SpriteTest, GraphicsEffects)
@@ -844,24 +854,22 @@ TEST(SpriteTest, GraphicsEffects)
 
     EngineMock engine;
     sprite.setEngine(&engine);
-    EXPECT_CALL(engine, requestRedraw()).Times(3);
+    EXPECT_CALL(engine, requestRedraw()).Times(4);
 
     GraphicsEffectMock effect1, effect2;
+    EXPECT_CALL(effect1, clamp(48.21)).WillOnce(Return(48.21));
     sprite.setGraphicsEffectValue(&effect1, 48.21);
     ASSERT_EQ(sprite.graphicsEffectValue(&effect1), 48.21);
     ASSERT_EQ(sprite.graphicsEffectValue(&effect2), 0);
 
+    EXPECT_CALL(effect2, clamp(-107.08)).WillOnce(Return(-107.08));
     sprite.setGraphicsEffectValue(&effect2, -107.08);
     ASSERT_EQ(sprite.graphicsEffectValue(&effect1), 48.21);
     ASSERT_EQ(sprite.graphicsEffectValue(&effect2), -107.08);
 
-    sprite.clearGraphicsEffects();
-    ASSERT_EQ(sprite.graphicsEffectValue(&effect1), 0);
-    ASSERT_EQ(sprite.graphicsEffectValue(&effect2), 0);
-
-    sprite.setVisible(false);
-    sprite.setGraphicsEffectValue(&effect2, -107.08);
-    ASSERT_EQ(sprite.graphicsEffectValue(&effect1), 0);
+    EXPECT_CALL(effect1, clamp(300)).WillOnce(Return(101.5));
+    sprite.setGraphicsEffectValue(&effect1, 300);
+    ASSERT_EQ(sprite.graphicsEffectValue(&effect1), 101.5);
     ASSERT_EQ(sprite.graphicsEffectValue(&effect2), -107.08);
 
     sprite.clearGraphicsEffects();
@@ -869,41 +877,30 @@ TEST(SpriteTest, GraphicsEffects)
     ASSERT_EQ(sprite.graphicsEffectValue(&effect2), 0);
 }
 
-TEST(SpriteTest, BubbleType)
+TEST(SpriteTest, BubbleTypeRedraw)
 {
     Sprite sprite;
     EngineMock engine;
     sprite.setEngine(&engine);
-    ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Say);
 
     EXPECT_CALL(engine, requestRedraw).Times(0);
-
-    sprite.setBubbleType(Target::BubbleType::Think);
-    ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Think);
-
-    sprite.setBubbleType(Target::BubbleType::Say);
-    ASSERT_EQ(sprite.bubbleType(), Target::BubbleType::Say);
+    sprite.bubble()->setType(TextBubble::Type::Say);
+    sprite.bubble()->setType(TextBubble::Type::Think);
 }
 
-TEST(SpriteTest, BubbleText)
+TEST(SpriteTest, BubbleTextRedraw)
 {
     Sprite sprite;
     EngineMock engine;
-    sprite.setVisible(true);
     sprite.setEngine(&engine);
-    ASSERT_TRUE(sprite.bubbleText().empty());
 
     EXPECT_CALL(engine, requestRedraw());
-    sprite.setBubbleText("hello");
-    ASSERT_EQ(sprite.bubbleText(), "hello");
-
-    EXPECT_CALL(engine, requestRedraw());
-    sprite.setBubbleText("world");
-    ASSERT_EQ(sprite.bubbleText(), "world");
+    sprite.bubble()->setText("hello");
 
     sprite.setVisible(false);
+    EXPECT_CALL(engine, requestRedraw).Times(0);
+    sprite.bubble()->setText("world");
 
     EXPECT_CALL(engine, requestRedraw).Times(0);
-    sprite.setBubbleText("test");
-    ASSERT_TRUE(sprite.bubbleText().empty());
+    sprite.bubble()->setText("");
 }
diff --git a/test/scratch_classes/stage_test.cpp b/test/scratch_classes/stage_test.cpp
index 78d3763b..d21156a9 100644
--- a/test/scratch_classes/stage_test.cpp
+++ b/test/scratch_classes/stage_test.cpp
@@ -1,5 +1,6 @@
 #include <scratchcpp/stage.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/textbubble.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/value.h>
 #include <enginemock.h>
@@ -184,7 +185,7 @@ TEST(StageTest, TouchingSprite)
     EXPECT_CALL(engine, cloneLimit()).WillRepeatedly(Return(-1));
     EXPECT_CALL(engine, initClone).Times(3);
     EXPECT_CALL(engine, requestRedraw).Times(3);
-    EXPECT_CALL(engine, moveSpriteBehindOther).Times(3);
+    EXPECT_CALL(engine, moveDrawableBehindOther).Times(3);
     auto clone1 = another.clone();
     auto clone2 = another.clone();
     auto clone3 = another.clone();
@@ -222,6 +223,7 @@ TEST(SpriteTest, TouchingColor)
 {
     Stage stage;
     ASSERT_FALSE(stage.touchingColor(0));
+    ASSERT_FALSE(stage.touchingColor(0, 0));
 
     StageHandlerMock iface;
     EXPECT_CALL(iface, init);
@@ -233,6 +235,12 @@ TEST(SpriteTest, TouchingColor)
 
     EXPECT_CALL(iface, touchingColor(v2)).WillOnce(Return(true));
     ASSERT_TRUE(stage.touchingColor(v2));
+
+    EXPECT_CALL(iface, touchingColor(v1, v2)).WillOnce(Return(false));
+    ASSERT_FALSE(stage.touchingColor(v1, v2));
+
+    EXPECT_CALL(iface, touchingColor(v2, v1)).WillOnce(Return(true));
+    ASSERT_TRUE(stage.touchingColor(v2, v1));
 }
 
 TEST(StageTest, GraphicsEffects)
@@ -241,44 +249,51 @@ TEST(StageTest, GraphicsEffects)
 
     EngineMock engine;
     stage.setEngine(&engine);
-    EXPECT_CALL(engine, requestRedraw()).Times(3);
+    EXPECT_CALL(engine, requestRedraw()).Times(4);
 
     GraphicsEffectMock effect1, effect2;
+    EXPECT_CALL(effect1, clamp(48.21)).WillOnce(Return(48.21));
     stage.setGraphicsEffectValue(&effect1, 48.21);
     ASSERT_EQ(stage.graphicsEffectValue(&effect1), 48.21);
     ASSERT_EQ(stage.graphicsEffectValue(&effect2), 0);
 
+    EXPECT_CALL(effect2, clamp(-107.08)).WillOnce(Return(-107.08));
     stage.setGraphicsEffectValue(&effect2, -107.08);
     ASSERT_EQ(stage.graphicsEffectValue(&effect1), 48.21);
     ASSERT_EQ(stage.graphicsEffectValue(&effect2), -107.08);
 
+    EXPECT_CALL(effect1, clamp(300)).WillOnce(Return(101.5));
+    stage.setGraphicsEffectValue(&effect1, 300);
+    ASSERT_EQ(stage.graphicsEffectValue(&effect1), 101.5);
+    ASSERT_EQ(stage.graphicsEffectValue(&effect2), -107.08);
+
     stage.clearGraphicsEffects();
     ASSERT_EQ(stage.graphicsEffectValue(&effect1), 0);
     ASSERT_EQ(stage.graphicsEffectValue(&effect2), 0);
 }
 
-TEST(StageTest, BubbleType)
+TEST(StageTest, BubbleTypeRedraw)
 {
     Stage stage;
-    ASSERT_EQ(stage.bubbleType(), Target::BubbleType::Say);
-
-    stage.setBubbleType(Target::BubbleType::Think);
-    ASSERT_EQ(stage.bubbleType(), Target::BubbleType::Think);
+    EngineMock engine;
+    stage.setEngine(&engine);
 
-    stage.setBubbleType(Target::BubbleType::Say);
-    ASSERT_EQ(stage.bubbleType(), Target::BubbleType::Say);
+    EXPECT_CALL(engine, requestRedraw).Times(0);
+    stage.bubble()->setType(TextBubble::Type::Say);
+    stage.bubble()->setType(TextBubble::Type::Think);
 }
 
-TEST(StageTest, BubbleText)
+TEST(StageTest, BubbleTextRedraw)
 {
     Stage stage;
-    ASSERT_TRUE(stage.bubbleText().empty());
+    EngineMock engine;
+    stage.setEngine(&engine);
 
-    stage.setBubbleText("hello");
-    ASSERT_EQ(stage.bubbleText(), "hello");
+    EXPECT_CALL(engine, requestRedraw());
+    stage.bubble()->setText("hello");
 
-    stage.setBubbleText("world");
-    ASSERT_EQ(stage.bubbleText(), "world");
+    EXPECT_CALL(engine, requestRedraw).Times(0);
+    stage.bubble()->setText("");
 }
 
 TEST(StageTest, LayerOrder)
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index e71771d2..bc4d9d95 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -1,5 +1,6 @@
 #include <scratchcpp/target.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/textbubble.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/block.h>
@@ -24,6 +25,18 @@ using ::testing::WithArgs;
 using ::testing::Invoke;
 using ::testing::_;
 
+TEST(TargetTest, IsTarget)
+{
+    Target target;
+    ASSERT_TRUE(target.isTarget());
+}
+
+TEST(TargetTest, IsTextBubble)
+{
+    Target target;
+    ASSERT_FALSE(target.isTextBubble());
+}
+
 TEST(TargetTest, IsStage)
 {
     Target target;
@@ -450,14 +463,6 @@ TEST(TargetTest, Sounds)
     SoundPrivate::audioOutput = nullptr;
 }
 
-TEST(TargetTest, LayerOrder)
-{
-    Target target;
-    ASSERT_EQ(target.layerOrder(), 0);
-    target.setLayerOrder(2);
-    ASSERT_EQ(target.layerOrder(), 2);
-}
-
 TEST(TargetTest, Volume)
 {
     Target target;
@@ -519,13 +524,36 @@ TEST(TargetTest, SoundEffects)
     ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 0);
 
     auto s1 = std::make_shared<SoundMock>();
+    EXPECT_CALL(*s1, setVolume);
+    target.addSound(s1);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pitch, -360));
+    target.setSoundEffectValue(Sound::Effect::Pitch, -400);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), -360);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pitch, 360));
+    target.setSoundEffectValue(Sound::Effect::Pitch, 400);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 360);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, -100));
+    target.setSoundEffectValue(Sound::Effect::Pan, -200);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), -100);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, 100));
+    target.setSoundEffectValue(Sound::Effect::Pan, 200);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 100);
+
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pitch, 0));
+    EXPECT_CALL(*s1, setEffect(Sound::Effect::Pan, 0));
+    target.clearSoundEffects();
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pitch), 0);
+    ASSERT_EQ(target.soundEffectValue(Sound::Effect::Pan), 0);
+
     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);
 
@@ -605,7 +633,7 @@ TEST(TargetTest, TouchingSprite)
     EXPECT_CALL(engine, cloneLimit()).WillRepeatedly(Return(-1));
     EXPECT_CALL(engine, initClone).Times(3);
     EXPECT_CALL(engine, requestRedraw).Times(3);
-    EXPECT_CALL(engine, moveSpriteBehindOther).Times(3);
+    EXPECT_CALL(engine, moveDrawableBehindOther).Times(3);
     auto clone1 = sprite.clone();
     auto clone2 = sprite.clone();
     auto clone3 = sprite.clone();
@@ -716,6 +744,7 @@ TEST(TargetTest, TouchingColor)
     Target target;
     Value v;
     ASSERT_FALSE(target.touchingColor(v));
+    ASSERT_FALSE(target.touchingColor(v, v));
 }
 
 TEST(TargetTest, GraphicsEffects)
@@ -726,70 +755,58 @@ TEST(TargetTest, GraphicsEffects)
     target.setEngine(&engine);
 
     GraphicsEffectMock effect1, effect2;
+    EXPECT_CALL(effect1, clamp(48.21)).WillOnce(Return(48.21));
     target.setGraphicsEffectValue(&effect1, 48.21);
     ASSERT_EQ(target.graphicsEffectValue(&effect1), 48.21);
     ASSERT_EQ(target.graphicsEffectValue(&effect2), 0);
 
+    EXPECT_CALL(effect2, clamp(-107.08)).WillOnce(Return(-107.08));
     target.setGraphicsEffectValue(&effect2, -107.08);
     ASSERT_EQ(target.graphicsEffectValue(&effect1), 48.21);
     ASSERT_EQ(target.graphicsEffectValue(&effect2), -107.08);
 
+    EXPECT_CALL(effect1, clamp(300)).WillOnce(Return(101.5));
+    target.setGraphicsEffectValue(&effect1, 300);
+    ASSERT_EQ(target.graphicsEffectValue(&effect1), 101.5);
+    ASSERT_EQ(target.graphicsEffectValue(&effect2), -107.08);
+
     target.clearGraphicsEffects();
     ASSERT_EQ(target.graphicsEffectValue(&effect1), 0);
     ASSERT_EQ(target.graphicsEffectValue(&effect2), 0);
 }
 
-TEST(TargetTest, BubbleType)
+TEST(SpriteTest, BubbleTypeRedraw)
 {
     Target target;
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
-
-    target.setBubbleType(Target::BubbleType::Think);
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Think);
+    EngineMock engine;
+    target.setEngine(&engine);
 
-    target.setBubbleType(Target::BubbleType::Say);
-    ASSERT_EQ(target.bubbleType(), Target::BubbleType::Say);
+    EXPECT_CALL(engine, requestRedraw).Times(0);
+    target.bubble()->setType(TextBubble::Type::Say);
+    target.bubble()->setType(TextBubble::Type::Think);
 }
 
-TEST(TargetTest, BubbleText)
+TEST(SpriteTest, BubbleTextRedraw)
 {
     Target target;
-    ASSERT_TRUE(target.bubbleText().empty());
-
-    target.setBubbleText("hello");
-    ASSERT_EQ(target.bubbleText(), "hello");
-
-    target.setBubbleText("world");
-    ASSERT_EQ(target.bubbleText(), "world");
-
-    // longstr.length = 384, should be limited to 330 in bubble text
-    std::string longstr =
-        "EY8OUNzAqwgh7NRGk5TzCP3dkAhJy9TX"
-        "Y9mqKElPjdQpKddYqjyCwUk2hx6YgVZV"
-        "6BOdmZGxDMs8Hjv8W9G6j4gTxAWdOkzs"
-        "8Ih80xzEDbvLilWsDwoB6FxH2kVVI4xs"
-        "IXOETNQ6QMsCKLWc5XjHk2BS9nYvDGpJ"
-        "uEmp9zIzFGT1kRSrOlU3ZwnN1YtvqFx"
-        "3hkWVNtJ71dQ0PJHhOVQPUy19V01SPu3"
-        "KIIS2wdSUVAc4RYMzepSveghzWbdcizy"
-        "Tm1KKAj4svu9YoL8b9vsolG8gKunvKO7"
-        "MurRKSeUbECELnJEKV6683xCq7RvmjAu"
-        "2djZ54apiQc1lTixWns5GoG0SVNuFzHl"
-        "q97qUiqiMecjVFM51YVif7c1Stip52Hl";
-
-    target.setBubbleText(longstr);
-    ASSERT_EQ(target.bubbleText().length(), 330);
-    ASSERT_EQ(target.bubbleText(), longstr.substr(0, 330));
+    EngineMock engine;
+    target.setEngine(&engine);
+
+    EXPECT_CALL(engine, requestRedraw).Times(0);
+    target.bubble()->setText("hello");
+    target.bubble()->setText("");
 }
 
 TEST(TargetTest, Engine)
 {
     Target target;
     ASSERT_EQ(target.engine(), nullptr);
+    ASSERT_EQ(target.bubble()->engine(), nullptr);
 
     EngineMock engine;
     target.setEngine(&engine);
     ASSERT_EQ(target.engine(), &engine);
+    ASSERT_EQ(target.bubble()->engine(), &engine);
 }
 
 TEST(TargetTest, DataSource)
diff --git a/test/scratch_classes/testextension.cpp b/test/scratch_classes/testextension.cpp
new file mode 100644
index 00000000..cd848ca6
--- /dev/null
+++ b/test/scratch_classes/testextension.cpp
@@ -0,0 +1,19 @@
+#include <scratchcpp/iengine.h>
+
+#include "testextension.h"
+
+using namespace libscratchcpp;
+
+std::string TestExtension::name() const
+{
+    return "Test";
+}
+
+std::string TestExtension::description() const
+{
+    return "";
+}
+
+void TestExtension::registerBlocks(IEngine *engine)
+{
+}
diff --git a/test/scratch_classes/testsection.h b/test/scratch_classes/testextension.h
similarity index 60%
rename from test/scratch_classes/testsection.h
rename to test/scratch_classes/testextension.h
index 78a0507d..88162cba 100644
--- a/test/scratch_classes/testsection.h
+++ b/test/scratch_classes/testextension.h
@@ -1,14 +1,15 @@
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 
 namespace libscratchcpp
 {
 
-class TestSection : public IBlockSection
+class TestExtension : public IExtension
 {
     public:
         std::string name() const override;
+        std::string description() const override;
 
         void registerBlocks(IEngine *engine) override;
 };
diff --git a/test/scratch_classes/testsection.cpp b/test/scratch_classes/testsection.cpp
deleted file mode 100644
index 255e6938..00000000
--- a/test/scratch_classes/testsection.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <scratchcpp/iengine.h>
-
-#include "testsection.h"
-
-using namespace libscratchcpp;
-
-std::string TestSection::name() const
-{
-    return "Test";
-}
-
-void TestSection::registerBlocks(IEngine *engine)
-{
-}
diff --git a/test/scratch_classes/textbubble_test.cpp b/test/scratch_classes/textbubble_test.cpp
new file mode 100644
index 00000000..77f30bc1
--- /dev/null
+++ b/test/scratch_classes/textbubble_test.cpp
@@ -0,0 +1,97 @@
+#include <scratchcpp/textbubble.h>
+#include <enginemock.h>
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(TextBubbleTest, IsTarget)
+{
+    TextBubble bubble;
+    ASSERT_FALSE(bubble.isTarget());
+}
+
+TEST(TextBubbleTest, IsTextBubble)
+{
+    TextBubble bubble;
+    ASSERT_TRUE(bubble.isTextBubble());
+}
+
+TEST(TextBubbleTest, BubbleType)
+{
+    TextBubble bubble;
+    ASSERT_EQ(bubble.type(), TextBubble::Type::Say);
+
+    bubble.setType(TextBubble::Type::Think);
+    ASSERT_EQ(bubble.type(), TextBubble::Type::Think);
+
+    bubble.setType(TextBubble::Type::Say);
+    ASSERT_EQ(bubble.type(), TextBubble::Type::Say);
+}
+
+TEST(TextBubbleTest, BubbleText)
+{
+    TextBubble bubble;
+    ASSERT_TRUE(bubble.text().empty());
+
+    bubble.setText("hello");
+    ASSERT_EQ(bubble.text(), "hello");
+
+    EngineMock engine;
+    bubble.setEngine(&engine);
+    EXPECT_CALL(engine, moveDrawableToFront(&bubble));
+    bubble.setText("world");
+    ASSERT_EQ(bubble.text(), "world");
+    bubble.setEngine(nullptr);
+
+    // longstr.length = 384, should be limited to 330 in bubble text
+    std::string longstr =
+        "EY8OUNzAqwgh7NRGk5TzCP3dkAhJy9TX"
+        "Y9mqKElPjdQpKddYqjyCwUk2hx6YgVZV"
+        "6BOdmZGxDMs8Hjv8W9G6j4gTxAWdOkzs"
+        "8Ih80xzEDbvLilWsDwoB6FxH2kVVI4xs"
+        "IXOETNQ6QMsCKLWc5XjHk2BS9nYvDGpJ"
+        "uEmp9zIzFGT1kRSrOlU3ZwnN1YtvqFx"
+        "3hkWVNtJ71dQ0PJHhOVQPUy19V01SPu3"
+        "KIIS2wdSUVAc4RYMzepSveghzWbdcizy"
+        "Tm1KKAj4svu9YoL8b9vsolG8gKunvKO7"
+        "MurRKSeUbECELnJEKV6683xCq7RvmjAu"
+        "2djZ54apiQc1lTixWns5GoG0SVNuFzHl"
+        "q97qUiqiMecjVFM51YVif7c1Stip52Hl";
+
+    bubble.setText(longstr);
+    ASSERT_EQ(bubble.text().length(), 330);
+    ASSERT_EQ(bubble.text(), longstr.substr(0, 330));
+
+    // Integers should be left unchanged
+    bubble.setText("8");
+    ASSERT_EQ(bubble.text(), "8");
+
+    bubble.setText("-52");
+    ASSERT_EQ(bubble.text(), "-52");
+
+    bubble.setText("0");
+    ASSERT_EQ(bubble.text(), "0");
+
+    // Non-integers should be rounded to 2 decimal places (no more, no less), unless they're small enough that rounding would display them as 0.00 (#478)
+    bubble.setText("8.324");
+    ASSERT_EQ(bubble.text(), "8.32");
+
+    bubble.setText("-52.576");
+    ASSERT_EQ(bubble.text(), "-52.58");
+
+    bubble.setText("3.5");
+    ASSERT_EQ(bubble.text(), "3.5");
+
+    bubble.setText("0.015");
+    ASSERT_EQ(bubble.text(), "0.02");
+
+    bubble.setText("-0.015");
+    ASSERT_EQ(bubble.text(), "-0.02");
+
+    bubble.setText("0.005");
+    ASSERT_EQ(bubble.text(), "0.005");
+
+    bubble.setText("-0.005");
+    ASSERT_EQ(bubble.text(), "-0.005");
+}
diff --git a/test/scratch_classes/value_test.cpp b/test/scratch_classes/value_test.cpp
index 69ea1fa0..814f1428 100644
--- a/test/scratch_classes/value_test.cpp
+++ b/test/scratch_classes/value_test.cpp
@@ -9,7 +9,7 @@ TEST(ValueTest, DefaultConstructor)
 {
     Value v;
     ASSERT_EQ(v.toInt(), 0);
-    ASSERT_EQ(v.type(), Value::Type::Integer);
+    ASSERT_EQ(v.type(), ValueType::Integer);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -25,7 +25,7 @@ TEST(ValueTest, FloatConstructor)
     {
         Value v(3.14f);
         ASSERT_EQ(v.toDouble(), 3.14);
-        ASSERT_EQ(v.type(), Value::Type::Double);
+        ASSERT_EQ(v.type(), ValueType::Double);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -38,7 +38,7 @@ TEST(ValueTest, FloatConstructor)
 
     {
         Value v(std::numeric_limits<float>::infinity());
-        ASSERT_EQ(v.type(), Value::Type::Infinity);
+        ASSERT_EQ(v.type(), ValueType::Infinity);
         ASSERT_TRUE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -50,7 +50,7 @@ TEST(ValueTest, FloatConstructor)
 
     {
         Value v(-std::numeric_limits<float>::infinity());
-        ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+        ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_TRUE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -62,7 +62,7 @@ TEST(ValueTest, FloatConstructor)
 
     {
         Value v(std::numeric_limits<float>::quiet_NaN());
-        ASSERT_EQ(v.type(), Value::Type::NaN);
+        ASSERT_EQ(v.type(), ValueType::NaN);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_TRUE(v.isNaN());
@@ -78,7 +78,7 @@ TEST(ValueTest, DoubleConstructor)
     {
         Value v(static_cast<double>(3.14));
         ASSERT_EQ(v.toDouble(), 3.14);
-        ASSERT_EQ(v.type(), Value::Type::Double);
+        ASSERT_EQ(v.type(), ValueType::Double);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -92,7 +92,7 @@ TEST(ValueTest, DoubleConstructor)
     {
         Value v(static_cast<double>(-5.0));
         ASSERT_EQ(v.toDouble(), -5.0);
-        ASSERT_EQ(v.type(), Value::Type::Double);
+        ASSERT_EQ(v.type(), ValueType::Double);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -105,7 +105,7 @@ TEST(ValueTest, DoubleConstructor)
 
     {
         Value v(std::numeric_limits<double>::infinity());
-        ASSERT_EQ(v.type(), Value::Type::Infinity);
+        ASSERT_EQ(v.type(), ValueType::Infinity);
         ASSERT_TRUE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -117,7 +117,7 @@ TEST(ValueTest, DoubleConstructor)
 
     {
         Value v(-std::numeric_limits<double>::infinity());
-        ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+        ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_TRUE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -129,7 +129,7 @@ TEST(ValueTest, DoubleConstructor)
 
     {
         Value v(std::numeric_limits<double>::quiet_NaN());
-        ASSERT_EQ(v.type(), Value::Type::NaN);
+        ASSERT_EQ(v.type(), ValueType::NaN);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_TRUE(v.isNaN());
@@ -144,7 +144,7 @@ TEST(ValueTest, IntConstructor)
 {
     Value v(static_cast<int>(55));
     ASSERT_EQ(v.toInt(), 55);
-    ASSERT_EQ(v.type(), Value::Type::Integer);
+    ASSERT_EQ(v.type(), ValueType::Integer);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -159,7 +159,7 @@ TEST(ValueTest, SizeTConstructor)
 {
     Value v(static_cast<size_t>(100));
     ASSERT_EQ(v.toLong(), 100);
-    ASSERT_EQ(v.type(), Value::Type::Integer);
+    ASSERT_EQ(v.type(), ValueType::Integer);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -174,7 +174,7 @@ TEST(ValueTest, LongConstructor)
 {
     Value v(999999999999999999L);
     ASSERT_EQ(v.toLong(), 999999999999999999L);
-    ASSERT_EQ(v.type(), Value::Type::Integer);
+    ASSERT_EQ(v.type(), ValueType::Integer);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -190,7 +190,7 @@ TEST(ValueTest, BoolConstructor)
     {
         Value v(true);
         ASSERT_EQ(v.toBool(), true);
-        ASSERT_EQ(v.type(), Value::Type::Bool);
+        ASSERT_EQ(v.type(), ValueType::Bool);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -204,7 +204,7 @@ TEST(ValueTest, BoolConstructor)
     {
         Value v(false);
         ASSERT_EQ(v.toBool(), false);
-        ASSERT_EQ(v.type(), Value::Type::Bool);
+        ASSERT_EQ(v.type(), ValueType::Bool);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -221,13 +221,13 @@ TEST(ValueTest, StdStringConstructor)
     {
         Value v(std::string("test"));
         ASSERT_EQ(v.toString(), "test");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
         ASSERT_FALSE(v.isNumber());
         ASSERT_FALSE(v.isValidNumber());
-        ASSERT_TRUE(v.isInt());
+        ASSERT_FALSE(v.isInt());
         ASSERT_FALSE(v.isBool());
         ASSERT_TRUE(v.isString());
     }
@@ -235,7 +235,7 @@ TEST(ValueTest, StdStringConstructor)
     {
         Value v(std::string("532"));
         ASSERT_EQ(v.toString(), "532");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -250,7 +250,7 @@ TEST(ValueTest, StdStringConstructor)
         Value v(std::string("532.15"));
 
         ASSERT_EQ(v.toString(), "532.15");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -264,13 +264,13 @@ TEST(ValueTest, StdStringConstructor)
     {
         Value v(std::string("1 2 3"));
         ASSERT_EQ(v.toString(), "1 2 3");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
         ASSERT_FALSE(v.isNumber());
         ASSERT_FALSE(v.isValidNumber());
-        ASSERT_TRUE(v.isInt());
+        ASSERT_FALSE(v.isInt());
         ASSERT_FALSE(v.isBool());
         ASSERT_TRUE(v.isString());
     }
@@ -279,13 +279,13 @@ TEST(ValueTest, StdStringConstructor)
         Value v(std::string(""));
 
         ASSERT_EQ(v.toString(), "");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
         ASSERT_FALSE(v.isNumber());
         ASSERT_TRUE(v.isValidNumber());
-        ASSERT_TRUE(v.isInt());
+        ASSERT_FALSE(v.isInt());
         ASSERT_FALSE(v.isBool());
         ASSERT_TRUE(v.isString());
     }
@@ -294,20 +294,20 @@ TEST(ValueTest, StdStringConstructor)
         Value v(std::string(" "));
 
         ASSERT_EQ(v.toString(), " ");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
         ASSERT_FALSE(v.isNumber());
         ASSERT_FALSE(v.isValidNumber());
-        ASSERT_TRUE(v.isInt());
+        ASSERT_FALSE(v.isInt());
         ASSERT_FALSE(v.isBool());
         ASSERT_TRUE(v.isString());
     }
 
     {
         Value v(std::string("Infinity"));
-        ASSERT_EQ(v.type(), Value::Type::Infinity);
+        ASSERT_EQ(v.type(), ValueType::Infinity);
         ASSERT_TRUE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -319,7 +319,7 @@ TEST(ValueTest, StdStringConstructor)
 
     {
         Value v(std::string("-Infinity"));
-        ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+        ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_TRUE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -331,7 +331,7 @@ TEST(ValueTest, StdStringConstructor)
 
     {
         Value v(std::string("NaN"));
-        ASSERT_EQ(v.type(), Value::Type::NaN);
+        ASSERT_EQ(v.type(), ValueType::NaN);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_TRUE(v.isNaN());
@@ -347,20 +347,20 @@ TEST(ValueTest, CStringConstructor)
     {
         Value v("test");
         ASSERT_EQ(v.toString(), "test");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
         ASSERT_FALSE(v.isNumber());
         ASSERT_FALSE(v.isValidNumber());
-        ASSERT_TRUE(v.isInt());
+        ASSERT_FALSE(v.isInt());
         ASSERT_FALSE(v.isBool());
         ASSERT_TRUE(v.isString());
     }
 
     {
         Value v("Infinity");
-        ASSERT_EQ(v.type(), Value::Type::Infinity);
+        ASSERT_EQ(v.type(), ValueType::Infinity);
         ASSERT_TRUE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -372,7 +372,7 @@ TEST(ValueTest, CStringConstructor)
 
     {
         Value v("-Infinity");
-        ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+        ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_TRUE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -384,7 +384,7 @@ TEST(ValueTest, CStringConstructor)
 
     {
         Value v("NaN");
-        ASSERT_EQ(v.type(), Value::Type::NaN);
+        ASSERT_EQ(v.type(), ValueType::NaN);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_TRUE(v.isNaN());
@@ -397,8 +397,8 @@ TEST(ValueTest, CStringConstructor)
 
 TEST(ValueTest, InfinityConstructor)
 {
-    Value v(Value::SpecialValue::Infinity);
-    ASSERT_EQ(v.type(), Value::Type::Infinity);
+    Value v(SpecialValue::Infinity);
+    ASSERT_EQ(v.type(), ValueType::Infinity);
     ASSERT_TRUE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -411,8 +411,8 @@ TEST(ValueTest, InfinityConstructor)
 
 TEST(ValueTest, NegativeInfinityConstructor)
 {
-    Value v(Value::SpecialValue::NegativeInfinity);
-    ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+    Value v(SpecialValue::NegativeInfinity);
+    ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_TRUE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -425,8 +425,8 @@ TEST(ValueTest, NegativeInfinityConstructor)
 
 TEST(ValueTest, NaNConstructor)
 {
-    Value v(Value::SpecialValue::NaN);
-    ASSERT_EQ(v.type(), Value::Type::NaN);
+    Value v(SpecialValue::NaN);
+    ASSERT_EQ(v.type(), ValueType::NaN);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_TRUE(v.isNaN());
@@ -496,7 +496,7 @@ TEST(ValueTest, CopyConstructor)
     }
 
     {
-        Value v1(Value::SpecialValue::NaN);
+        Value v1(SpecialValue::NaN);
         Value v2(v1);
         ASSERT_EQ(v2.toDouble(), 0);
         ASSERT_EQ(v1.type(), v2.type());
@@ -510,7 +510,7 @@ TEST(ValueTest, CopyConstructor)
     }
 
     {
-        Value v1(Value::SpecialValue::Infinity);
+        Value v1(SpecialValue::Infinity);
         Value v2(v1);
         ASSERT_EQ(v1.type(), v2.type());
         ASSERT_TRUE(v2.isInfinity());
@@ -523,7 +523,7 @@ TEST(ValueTest, CopyConstructor)
     }
 
     {
-        Value v1(Value::SpecialValue::NegativeInfinity);
+        Value v1(SpecialValue::NegativeInfinity);
         Value v2(v1);
         ASSERT_EQ(v1.type(), v2.type());
         ASSERT_FALSE(v2.isInfinity());
@@ -541,7 +541,7 @@ TEST(ValueTest, FloatAssignment)
     Value v;
     v = 3.14f;
     ASSERT_EQ(v.toDouble(), 3.14);
-    ASSERT_EQ(v.type(), Value::Type::Double);
+    ASSERT_EQ(v.type(), ValueType::Double);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -551,7 +551,7 @@ TEST(ValueTest, FloatAssignment)
     ASSERT_FALSE(v.isString());
 
     v = std::numeric_limits<float>::infinity();
-    ASSERT_EQ(v.type(), Value::Type::Infinity);
+    ASSERT_EQ(v.type(), ValueType::Infinity);
     ASSERT_TRUE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -561,7 +561,7 @@ TEST(ValueTest, FloatAssignment)
     ASSERT_FALSE(v.isString());
 
     v = -std::numeric_limits<float>::infinity();
-    ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+    ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_TRUE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -571,7 +571,7 @@ TEST(ValueTest, FloatAssignment)
     ASSERT_FALSE(v.isString());
 
     v = -std::numeric_limits<float>::quiet_NaN();
-    ASSERT_EQ(v.type(), Value::Type::NaN);
+    ASSERT_EQ(v.type(), ValueType::NaN);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_TRUE(v.isNaN());
@@ -586,7 +586,7 @@ TEST(ValueTest, DoubleAssignment)
     Value v;
     v = static_cast<double>(3.14);
     ASSERT_EQ(v.toDouble(), 3.14);
-    ASSERT_EQ(v.type(), Value::Type::Double);
+    ASSERT_EQ(v.type(), ValueType::Double);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -596,7 +596,7 @@ TEST(ValueTest, DoubleAssignment)
     ASSERT_FALSE(v.isString());
 
     v = std::numeric_limits<double>::infinity();
-    ASSERT_EQ(v.type(), Value::Type::Infinity);
+    ASSERT_EQ(v.type(), ValueType::Infinity);
     ASSERT_TRUE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -606,7 +606,7 @@ TEST(ValueTest, DoubleAssignment)
     ASSERT_FALSE(v.isString());
 
     v = -std::numeric_limits<double>::infinity();
-    ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+    ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_TRUE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -616,7 +616,7 @@ TEST(ValueTest, DoubleAssignment)
     ASSERT_FALSE(v.isString());
 
     v = -std::numeric_limits<double>::quiet_NaN();
-    ASSERT_EQ(v.type(), Value::Type::NaN);
+    ASSERT_EQ(v.type(), ValueType::NaN);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_TRUE(v.isNaN());
@@ -631,7 +631,7 @@ TEST(ValueTest, IntAssignment)
     Value v;
     v = static_cast<int>(55);
     ASSERT_EQ(v.toInt(), 55);
-    ASSERT_EQ(v.type(), Value::Type::Integer);
+    ASSERT_EQ(v.type(), ValueType::Integer);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -646,7 +646,7 @@ TEST(ValueTest, LongAssignment)
     Value v;
     v = 999999999999999999L;
     ASSERT_EQ(v.toLong(), 999999999999999999L);
-    ASSERT_EQ(v.type(), Value::Type::Integer);
+    ASSERT_EQ(v.type(), ValueType::Integer);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -662,7 +662,7 @@ TEST(ValueTest, BoolAssignment)
         Value v;
         v = true;
         ASSERT_EQ(v.toBool(), true);
-        ASSERT_EQ(v.type(), Value::Type::Bool);
+        ASSERT_EQ(v.type(), ValueType::Bool);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -676,7 +676,7 @@ TEST(ValueTest, BoolAssignment)
         Value v;
         v = false;
         ASSERT_EQ(v.toBool(), false);
-        ASSERT_EQ(v.type(), Value::Type::Bool);
+        ASSERT_EQ(v.type(), ValueType::Bool);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -693,7 +693,7 @@ TEST(ValueTest, StdStringAssignment)
         Value v;
         v = std::string("test");
         ASSERT_EQ(v.toString(), "test");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -707,7 +707,7 @@ TEST(ValueTest, StdStringAssignment)
         Value v;
         v = std::string("Infinity");
         ASSERT_EQ(v.toString(), "Infinity");
-        ASSERT_EQ(v.type(), Value::Type::Infinity);
+        ASSERT_EQ(v.type(), ValueType::Infinity);
         ASSERT_TRUE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -721,7 +721,7 @@ TEST(ValueTest, StdStringAssignment)
         Value v;
         v = std::string("-Infinity");
         ASSERT_EQ(v.toString(), "-Infinity");
-        ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+        ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_TRUE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -735,7 +735,7 @@ TEST(ValueTest, StdStringAssignment)
         Value v;
         v = std::string("NaN");
         ASSERT_EQ(v.toString(), "NaN");
-        ASSERT_EQ(v.type(), Value::Type::NaN);
+        ASSERT_EQ(v.type(), ValueType::NaN);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_TRUE(v.isNaN());
@@ -752,7 +752,7 @@ TEST(ValueTest, CStringAssignment)
         Value v;
         v = "test";
         ASSERT_EQ(v.toString(), "test");
-        ASSERT_EQ(v.type(), Value::Type::String);
+        ASSERT_EQ(v.type(), ValueType::String);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -766,7 +766,7 @@ TEST(ValueTest, CStringAssignment)
         Value v;
         v = "Infinity";
         ASSERT_EQ(v.toString(), "Infinity");
-        ASSERT_EQ(v.type(), Value::Type::Infinity);
+        ASSERT_EQ(v.type(), ValueType::Infinity);
         ASSERT_TRUE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -780,7 +780,7 @@ TEST(ValueTest, CStringAssignment)
         Value v;
         v = "-Infinity";
         ASSERT_EQ(v.toString(), "-Infinity");
-        ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+        ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_TRUE(v.isNegativeInfinity());
         ASSERT_FALSE(v.isNaN());
@@ -794,7 +794,7 @@ TEST(ValueTest, CStringAssignment)
         Value v;
         v = "NaN";
         ASSERT_EQ(v.toString(), "NaN");
-        ASSERT_EQ(v.type(), Value::Type::NaN);
+        ASSERT_EQ(v.type(), ValueType::NaN);
         ASSERT_FALSE(v.isInfinity());
         ASSERT_FALSE(v.isNegativeInfinity());
         ASSERT_TRUE(v.isNaN());
@@ -808,8 +808,8 @@ TEST(ValueTest, CStringAssignment)
 TEST(ValueTest, InfinityAssignment)
 {
     Value v;
-    v = Value::SpecialValue::Infinity;
-    ASSERT_EQ(v.type(), Value::Type::Infinity);
+    v = SpecialValue::Infinity;
+    ASSERT_EQ(v.type(), ValueType::Infinity);
     ASSERT_TRUE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -822,8 +822,8 @@ TEST(ValueTest, InfinityAssignment)
 TEST(ValueTest, NegativeInfinityAssignment)
 {
     Value v;
-    v = Value::SpecialValue::NegativeInfinity;
-    ASSERT_EQ(v.type(), Value::Type::NegativeInfinity);
+    v = SpecialValue::NegativeInfinity;
+    ASSERT_EQ(v.type(), ValueType::NegativeInfinity);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_TRUE(v.isNegativeInfinity());
     ASSERT_FALSE(v.isNaN());
@@ -836,8 +836,8 @@ TEST(ValueTest, NegativeInfinityAssignment)
 TEST(ValueTest, NaNAssignment)
 {
     Value v;
-    v = Value::SpecialValue::NaN;
-    ASSERT_EQ(v.type(), Value::Type::NaN);
+    v = SpecialValue::NaN;
+    ASSERT_EQ(v.type(), ValueType::NaN);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
     ASSERT_TRUE(v.isNaN());
@@ -910,7 +910,7 @@ TEST(ValueTest, CopyAssignment)
     }
 
     {
-        Value v1(Value::SpecialValue::NaN);
+        Value v1(SpecialValue::NaN);
         Value v2;
         v2 = v1;
         ASSERT_EQ(v2.toDouble(), 0);
@@ -925,7 +925,7 @@ TEST(ValueTest, CopyAssignment)
     }
 
     {
-        Value v1(Value::SpecialValue::Infinity);
+        Value v1(SpecialValue::Infinity);
         Value v2;
         v2 = v1;
         ASSERT_EQ(v1.type(), v2.type());
@@ -939,7 +939,7 @@ TEST(ValueTest, CopyAssignment)
     }
 
     {
-        Value v1(Value::SpecialValue::NegativeInfinity);
+        Value v1(SpecialValue::NegativeInfinity);
         Value v2;
         v2 = v1;
         ASSERT_EQ(v1.type(), v2.type());
@@ -1005,6 +1005,18 @@ TEST(ValueTest, ToInt)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 2814);
 
+    v = "   0xafe";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 2814);
+
+    v = "0xafe   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 2814);
+
+    v = "   0xafe   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 2814);
+
     v = "0x0afe";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 2814);
@@ -1021,11 +1033,27 @@ TEST(ValueTest, ToInt)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 0);
 
+    v = "0xabf.d";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 0);
+
     // Octal
     v = "0o506";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 326);
 
+    v = "   0o506";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 326);
+
+    v = "0o506   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 326);
+
+    v = "   0o506   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 326);
+
     v = "0o0506";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 326);
@@ -1038,11 +1066,27 @@ TEST(ValueTest, ToInt)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 0);
 
+    v = "0o573.2";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 0);
+
     // Binary
     v = "0b101101";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 45);
 
+    v = "   0b101101";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 45);
+
+    v = "0b101101   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 45);
+
+    v = "   0b101101   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 45);
+
     v = "0b0101101";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 45);
@@ -1054,6 +1098,10 @@ TEST(ValueTest, ToInt)
     v = "0b100112001";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toInt(), 0);
+
+    v = "0b10011001.1";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toInt(), 0);
 }
 
 TEST(ValueTest, ToLong)
@@ -1078,11 +1126,6 @@ TEST(ValueTest, ToLong)
     v = true;
     ASSERT_EQ(v.toLong(), 1);
 
-    v = "999999999999999999";
-    ASSERT_EQ(v.toLong(), 999999999999999999L);
-    v = "-999999999999999999";
-    ASSERT_EQ(v.toLong(), -999999999999999999L);
-
     v = "255.625";
     ASSERT_EQ(v.toLong(), 255);
     v = "-255.625";
@@ -1108,6 +1151,18 @@ TEST(ValueTest, ToLong)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 2814);
 
+    v = "   0xafe";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 2814);
+
+    v = "0xafe   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 2814);
+
+    v = "   0xafe   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 2814);
+
     v = "0x0afe";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 2814);
@@ -1124,11 +1179,27 @@ TEST(ValueTest, ToLong)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 0);
 
+    v = "0xabf.d";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 0);
+
     // Octal
     v = "0o506";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 326);
 
+    v = "   0o506";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 326);
+
+    v = "0o506   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 326);
+
+    v = "   0o506   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 326);
+
     v = "0o0506";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 326);
@@ -1141,11 +1212,27 @@ TEST(ValueTest, ToLong)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 0);
 
+    v = "0o573.2";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 0);
+
     // Binary
     v = "0b101101";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 45);
 
+    v = "   0b101101";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 45);
+
+    v = "0b101101   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 45);
+
+    v = "   0b101101   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 45);
+
     v = "0b0101101";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 45);
@@ -1157,10 +1244,17 @@ TEST(ValueTest, ToLong)
     v = "0b100112001";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toLong(), 0);
+
+    v = "0b100112001.1";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toLong(), 0);
 }
 
 TEST(ValueTest, ToDouble)
 {
+    std::string oldLocale = std::setlocale(LC_NUMERIC, nullptr);
+    std::setlocale(LC_NUMERIC, "sk_SK.UTF-8");
+
     Value v = 2147483647;
     ASSERT_EQ(v.toDouble(), 2147483647.0);
     v = -2147483647;
@@ -1191,6 +1285,30 @@ TEST(ValueTest, ToDouble)
     v = "-255.625";
     ASSERT_EQ(v.toDouble(), -255.625);
 
+    v = "0.15";
+    ASSERT_EQ(v.toDouble(), 0.15);
+    v = "-0.15";
+    ASSERT_EQ(v.toDouble(), -0.15);
+
+    v = "+.15";
+    ASSERT_EQ(v.toDouble(), 0.15);
+    v = ".15";
+    ASSERT_EQ(v.toDouble(), 0.15);
+    v = "-.15";
+    ASSERT_EQ(v.toDouble(), -0.15);
+
+    v = "1.";
+    ASSERT_EQ(v.toDouble(), 1);
+    v = "+1.";
+    ASSERT_EQ(v.toDouble(), 1);
+    v = "-1.";
+    ASSERT_EQ(v.toDouble(), -1);
+
+    v = "0+5";
+    ASSERT_EQ(v.toDouble(), 0);
+    v = "0-5";
+    ASSERT_EQ(v.toDouble(), 0);
+
     v = "9432.4e-12";
     ASSERT_EQ(v.toDouble(), 9.4324e-9);
     v = "-9432.4e-12";
@@ -1201,6 +1319,9 @@ TEST(ValueTest, ToDouble)
     v = "-9432.4e+6";
     ASSERT_EQ(v.toDouble(), -9.4324e+9);
 
+    v = "1 2 3";
+    ASSERT_EQ(v.toDouble(), 0);
+
     v = "false";
     ASSERT_EQ(v.toDouble(), 0.0);
     v = "true";
@@ -1221,6 +1342,18 @@ TEST(ValueTest, ToDouble)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 2814);
 
+    v = "   0xafe";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 2814);
+
+    v = "0xafe   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 2814);
+
+    v = "   0xafe   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 2814);
+
     v = "0x0afe";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 2814);
@@ -1237,11 +1370,43 @@ TEST(ValueTest, ToDouble)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 0);
 
+    v = "0xabf.d";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "+0xa";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "-0xa";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "0x+a";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "0x-a";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
     // Octal
     v = "0o506";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 326);
 
+    v = "   0o506";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 326);
+
+    v = "0o506   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 326);
+
+    v = "   0o506   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 326);
+
     v = "0o0506";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 326);
@@ -1254,11 +1419,43 @@ TEST(ValueTest, ToDouble)
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 0);
 
+    v = "0o573.2";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "+0o2";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "-0o2";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "0o+2";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "0o-2";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
     // Binary
     v = "0b101101";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 45);
 
+    v = "   0b101101";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 45);
+
+    v = "0b101101   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 45);
+
+    v = "   0b101101   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 45);
+
     v = "0b0101101";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 45);
@@ -1270,6 +1467,28 @@ TEST(ValueTest, ToDouble)
     v = "0b100112001";
     ASSERT_TRUE(v.isString());
     ASSERT_EQ(v.toDouble(), 0);
+
+    v = "0b10011001.1";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "+0b1";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "-0b1";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "0b+1";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    v = "0b-1";
+    ASSERT_TRUE(v.isString());
+    ASSERT_EQ(v.toDouble(), 0);
+
+    std::setlocale(LC_NUMERIC, oldLocale.c_str());
 }
 
 TEST(ValueTest, ToBool)
@@ -1340,6 +1559,18 @@ TEST(ValueTest, ToBool)
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
 
+    v = "   0xafe";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
+    v = "0xafe   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
+    v = "   0xafe   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
     v = "0x0afe";
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
@@ -1360,11 +1591,27 @@ TEST(ValueTest, ToBool)
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
 
+    v = "0xabf.d";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
     // Octal
     v = "0o506";
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
 
+    v = "   0o506";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
+    v = "0o506   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
+    v = "   0o506   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
     v = "0o0506";
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
@@ -1377,11 +1624,27 @@ TEST(ValueTest, ToBool)
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
 
+    v = "0o573.2";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
     // Binary
     v = "0b101101";
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
 
+    v = "   0b101101";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
+    v = "0b101101   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
+    v = "   0b101101   ";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
+
     v = "0b0101101";
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
@@ -1393,6 +1656,10 @@ TEST(ValueTest, ToBool)
     v = "0b100112001";
     ASSERT_TRUE(v.isString());
     ASSERT_TRUE(v.toBool());
+
+    v = "0b10011001.1";
+    ASSERT_TRUE(v.isString());
+    ASSERT_TRUE(v.toBool());
 }
 
 TEST(ValueTest, ToString)
@@ -2270,12 +2537,37 @@ TEST(ValueTest, EqualityOperators)
     }
 
     {
-        Value v1(Value::SpecialValue::Infinity);
-        Value v2(Value::SpecialValue::Infinity);
-        Value v3(Value::SpecialValue::NegativeInfinity);
-        Value v4(Value::SpecialValue::NegativeInfinity);
-        Value v5(Value::SpecialValue::NaN);
-        Value v6(Value::SpecialValue::NaN);
+        Value v1 = " ";
+        Value v2 = "";
+        Value v3 = "0";
+        Value v4 = 0;
+
+        ASSERT_FALSE(v1 == v2);
+        ASSERT_TRUE(v1 != v2);
+
+        ASSERT_FALSE(v1 == v3);
+        ASSERT_TRUE(v1 != v3);
+
+        ASSERT_FALSE(v1 == v4);
+        ASSERT_TRUE(v1 != v4);
+
+        ASSERT_FALSE(v2 == v3);
+        ASSERT_TRUE(v2 != v3);
+
+        ASSERT_FALSE(v2 == v4);
+        ASSERT_TRUE(v2 != v4);
+
+        ASSERT_TRUE(v3 == v4);
+        ASSERT_FALSE(v3 != v4);
+    }
+
+    {
+        Value v1(SpecialValue::Infinity);
+        Value v2(SpecialValue::Infinity);
+        Value v3(SpecialValue::NegativeInfinity);
+        Value v4(SpecialValue::NegativeInfinity);
+        Value v5(SpecialValue::NaN);
+        Value v6(SpecialValue::NaN);
 
         ASSERT_TRUE(v1 == v2);
         ASSERT_FALSE(v1 != v2);
@@ -2408,9 +2700,9 @@ TEST(ValueTest, EqualityOperators)
     {
         Value v1 = 5;
         Value v2 = 0;
-        Value v3(Value::SpecialValue::Infinity);
-        Value v4(Value::SpecialValue::NegativeInfinity);
-        Value v5(Value::SpecialValue::NaN);
+        Value v3(SpecialValue::Infinity);
+        Value v4(SpecialValue::NegativeInfinity);
+        Value v5(SpecialValue::NaN);
 
         ASSERT_FALSE(v1 == v3);
         ASSERT_TRUE(v1 != v3);
@@ -2512,9 +2804,9 @@ TEST(ValueTest, EqualityOperators)
     {
         Value v1 = true;
         Value v2 = false;
-        Value v3(Value::SpecialValue::Infinity);
-        Value v4(Value::SpecialValue::NegativeInfinity);
-        Value v5(Value::SpecialValue::NaN);
+        Value v3(SpecialValue::Infinity);
+        Value v4(SpecialValue::NegativeInfinity);
+        Value v5(SpecialValue::NaN);
 
         ASSERT_FALSE(v1 == v3);
         ASSERT_TRUE(v1 != v3);
@@ -2536,9 +2828,9 @@ TEST(ValueTest, EqualityOperators)
         Value v4 = "-infinity";
         Value v5 = "NaN";
         Value v6 = "nan";
-        Value v7(Value::SpecialValue::Infinity);
-        Value v8(Value::SpecialValue::NegativeInfinity);
-        Value v9(Value::SpecialValue::NaN);
+        Value v7(SpecialValue::Infinity);
+        Value v8(SpecialValue::NegativeInfinity);
+        Value v9(SpecialValue::NaN);
 
         // Infinity
         ASSERT_TRUE(v1 == v7);
@@ -2606,9 +2898,9 @@ TEST(ValueTest, EqualityOperators)
         Value v2 = " ";
         Value v3 = "";
         Value v4 = "0";
-        Value v5(Value::SpecialValue::Infinity);
-        Value v6(Value::SpecialValue::NegativeInfinity);
-        Value v7(Value::SpecialValue::NaN);
+        Value v5(SpecialValue::Infinity);
+        Value v6(SpecialValue::NegativeInfinity);
+        Value v7(SpecialValue::NaN);
 
         // Infinity
         ASSERT_FALSE(v1 == v5);
diff --git a/test/scratchconfiguration/extensionbase.cpp b/test/scratchconfiguration/extensionbase.cpp
index 71fc7960..185f3ae4 100644
--- a/test/scratchconfiguration/extensionbase.cpp
+++ b/test/scratchconfiguration/extensionbase.cpp
@@ -2,11 +2,16 @@
 
 using namespace libscratchcpp;
 
+std::string ExtensionBase::name() const
+{
+    return "";
+}
+
 std::string ExtensionBase::description() const
 {
     return "";
 }
 
-void ExtensionBase::registerSections(IEngine *engine)
+void ExtensionBase::registerBlocks(IEngine *engine)
 {
 }
diff --git a/test/scratchconfiguration/extensionbase.h b/test/scratchconfiguration/extensionbase.h
index 62e13a5e..95b113cb 100644
--- a/test/scratchconfiguration/extensionbase.h
+++ b/test/scratchconfiguration/extensionbase.h
@@ -8,9 +8,10 @@ namespace libscratchcpp
 class ExtensionBase : public IExtension
 {
     public:
+        std::string name() const override;
         std::string description() const override;
 
-        void registerSections(IEngine *engine) override;
+        void registerBlocks(IEngine *engine) override;
 };
 
 } // namespace libscratchcpp
diff --git a/test/scratchconfiguration/scratchconfiguration_test.cpp b/test/scratchconfiguration/scratchconfiguration_test.cpp
index f1bc03b2..f26e5bdf 100644
--- a/test/scratchconfiguration/scratchconfiguration_test.cpp
+++ b/test/scratchconfiguration/scratchconfiguration_test.cpp
@@ -37,6 +37,14 @@ TEST_F(ScratchConfigurationTest, Extensions)
     ASSERT_EQ(ScratchConfiguration::getExtension<Extension1>(), m_extension1.get());
     ASSERT_EQ(ScratchConfiguration::getExtension<Extension2>(), m_extension2.get());
     ASSERT_EQ(ScratchConfiguration::getExtension<Extension3>(), nullptr);
+
+    ScratchConfiguration::removeExtension(m_extension1);
+
+    ASSERT_EQ(ScratchConfiguration::getExtension("ext 1"), nullptr);
+    ASSERT_EQ(ScratchConfiguration::getExtension("ext 2"), m_extension2.get());
+
+    ASSERT_EQ(ScratchConfiguration::getExtension<Extension1>(), nullptr);
+    ASSERT_EQ(ScratchConfiguration::getExtension<Extension2>(), m_extension2.get());
 }
 
 TEST_F(ScratchConfigurationTest, GraphicsEffects)
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 7faf3c49..8096413a 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -1,6 +1,7 @@
 #include <scratchcpp/script.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/virtualmachine.h>
+#include <scratchcpp/thread.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/variable.h>
@@ -161,24 +162,24 @@ TEST_F(ScriptTest, Start)
 
     Script script1(nullptr, nullptr, nullptr);
 
-    std::shared_ptr<VirtualMachine> vm = script1.start();
-    ASSERT_TRUE(vm);
-    ASSERT_EQ(vm->target(), nullptr);
-    ASSERT_EQ(vm->engine(), nullptr);
-    ASSERT_EQ(vm->bytecode(), nullptr);
-    ASSERT_EQ(vm->procedures(), nullptr);
-    ASSERT_EQ(vm->functions(), nullptr);
-    ASSERT_EQ(vm->constValues(), nullptr);
-    ASSERT_EQ(vm->variables(), nullptr);
-    ASSERT_EQ(vm->lists(), nullptr);
+    std::shared_ptr<Thread> thread = script1.start();
+    ASSERT_TRUE(thread);
+    ASSERT_EQ(thread->target(), nullptr);
+    ASSERT_EQ(thread->engine(), nullptr);
+    ASSERT_EQ(thread->vm()->bytecode(), nullptr);
+    ASSERT_EQ(thread->vm()->procedures(), nullptr);
+    ASSERT_EQ(thread->vm()->functions(), nullptr);
+    ASSERT_EQ(thread->vm()->constValues(), nullptr);
+    ASSERT_EQ(thread->vm()->variables(), nullptr);
+    ASSERT_EQ(thread->vm()->lists(), nullptr);
 
     Script script2(&m_target, nullptr, &m_engine);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(noFunctions));
-    vm = script2.start();
-    ASSERT_TRUE(vm);
-    ASSERT_EQ(vm->target(), &m_target);
-    ASSERT_EQ(vm->engine(), &m_engine);
+    thread = script2.start();
+    ASSERT_TRUE(thread);
+    ASSERT_EQ(thread->target(), &m_target);
+    ASSERT_EQ(thread->engine(), &m_engine);
 
     Script script3(&m_target, nullptr, &m_engine);
     script3.setBytecode(bytecode);
@@ -188,28 +189,28 @@ TEST_F(ScriptTest, Start)
     script3.setLists(lists);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions));
-    vm = script3.start();
-    ASSERT_TRUE(vm);
-    ASSERT_EQ(vm->bytecode()[0], bytecode[0]);
-    ASSERT_EQ(vm->procedures()[0], procedures[0]);
-    ASSERT_EQ(vm->functions()[0], functions[0]);
-    ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
-    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
-    ASSERT_EQ(vm->lists()[0], lists[0]);
+    thread = script3.start();
+    ASSERT_TRUE(thread);
+    ASSERT_EQ(thread->vm()->bytecode()[0], bytecode[0]);
+    ASSERT_EQ(thread->vm()->procedures()[0], procedures[0]);
+    ASSERT_EQ(thread->vm()->functions()[0], functions[0]);
+    ASSERT_EQ(thread->vm()->constValues()[0].toString(), constValues[0].toString());
+    ASSERT_EQ(thread->vm()->variables()[0], variables[0]->valuePtr());
+    ASSERT_EQ(thread->vm()->lists()[0], lists[0]);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions));
     Target target;
     target.addVariable(var1);
     target.addList(list1);
-    vm = script3.start(&target);
-    ASSERT_TRUE(vm);
-    ASSERT_EQ(vm->target(), &target);
-    ASSERT_EQ(vm->bytecode()[0], bytecode[0]);
-    ASSERT_EQ(vm->procedures()[0], procedures[0]);
-    ASSERT_EQ(vm->functions()[0], functions[0]);
-    ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
-    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
-    ASSERT_EQ(vm->lists()[0], lists[0]);
+    thread = script3.start(&target);
+    ASSERT_TRUE(thread);
+    ASSERT_EQ(thread->target(), &target);
+    ASSERT_EQ(thread->vm()->bytecode()[0], bytecode[0]);
+    ASSERT_EQ(thread->vm()->procedures()[0], procedures[0]);
+    ASSERT_EQ(thread->vm()->functions()[0], functions[0]);
+    ASSERT_EQ(thread->vm()->constValues()[0].toString(), constValues[0].toString());
+    ASSERT_EQ(thread->vm()->variables()[0], variables[0]->valuePtr());
+    ASSERT_EQ(thread->vm()->lists()[0], lists[0]);
 
     Sprite root;
     root.setEngine(&m_engine);
@@ -219,7 +220,7 @@ TEST_F(ScriptTest, Start)
     EXPECT_CALL(m_engine, cloneLimit()).Times(2).WillRepeatedly(Return(300));
     EXPECT_CALL(m_engine, cloneCount()).WillOnce(Return(0));
     EXPECT_CALL(m_engine, initClone).Times(1);
-    EXPECT_CALL(m_engine, moveSpriteBehindOther(_, &root));
+    EXPECT_CALL(m_engine, moveDrawableBehindOther(_, &root));
     EXPECT_CALL(m_engine, requestRedraw());
     auto clone = root.clone();
 
@@ -231,18 +232,18 @@ TEST_F(ScriptTest, Start)
     script4.setLists(lists);
 
     EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions));
-    vm = script4.start(clone.get());
-
-    ASSERT_TRUE(vm);
-    ASSERT_EQ(vm->target(), clone.get());
-    ASSERT_EQ(vm->bytecode()[0], bytecode[0]);
-    ASSERT_EQ(vm->procedures()[0], procedures[0]);
-    ASSERT_EQ(vm->functions()[0], functions[0]);
-    ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
-    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
-    ASSERT_EQ(vm->variables()[1], clone->variableAt(clone->findVariableById("b"))->valuePtr());
-    ASSERT_EQ(vm->lists()[0], lists[0]);
-    ASSERT_EQ(vm->lists()[1], clone->listAt(clone->findListById("d")).get());
+    thread = script4.start(clone.get());
+
+    ASSERT_TRUE(thread);
+    ASSERT_EQ(thread->target(), clone.get());
+    ASSERT_EQ(thread->vm()->bytecode()[0], bytecode[0]);
+    ASSERT_EQ(thread->vm()->procedures()[0], procedures[0]);
+    ASSERT_EQ(thread->vm()->functions()[0], functions[0]);
+    ASSERT_EQ(thread->vm()->constValues()[0].toString(), constValues[0].toString());
+    ASSERT_EQ(thread->vm()->variables()[0], variables[0]->valuePtr());
+    ASSERT_EQ(thread->vm()->variables()[1], clone->variableAt(clone->findVariableById("b"))->valuePtr());
+    ASSERT_EQ(thread->vm()->lists()[0], lists[0]);
+    ASSERT_EQ(thread->vm()->lists()[1], clone->listAt(clone->findListById("d")).get());
 
     EXPECT_CALL(m_engine, deinitClone(clone));
     clone->deleteClone();
diff --git a/test/target_interfaces/ispritehandler_test.cpp b/test/target_interfaces/ispritehandler_test.cpp
index 752593e9..a9da4699 100644
--- a/test/target_interfaces/ispritehandler_test.cpp
+++ b/test/target_interfaces/ispritehandler_test.cpp
@@ -30,11 +30,11 @@ class ISpriteHandlerTest : public testing::Test
 TEST_F(ISpriteHandlerTest, Clone)
 {
     std::shared_ptr<Sprite> clone;
-    Sprite *cloneParam1, *cloneParam2;
+    Drawable *cloneParam1, *cloneParam2;
     EXPECT_CALL(m_engine, cloneLimit()).Times(2).WillRepeatedly(Return(300));
     EXPECT_CALL(m_engine, cloneCount()).WillOnce(Return(0));
     EXPECT_CALL(m_engine, initClone(_)).WillOnce(SaveArg<0>(&clone));
-    EXPECT_CALL(m_engine, moveSpriteBehindOther(_, &m_sprite)).WillOnce(SaveArg<0>(&cloneParam1));
+    EXPECT_CALL(m_engine, moveDrawableBehindOther(_, &m_sprite)).WillOnce(SaveArg<0>(&cloneParam1));
     EXPECT_CALL(m_handler, onCloned(_)).WillOnce(SaveArg<0>(&cloneParam2));
     EXPECT_CALL(m_engine, requestRedraw());
 
@@ -186,22 +186,6 @@ TEST_F(ISpriteHandlerTest, GraphicsEffects)
     m_sprite.clearGraphicsEffects();
 }
 
-TEST_F(ISpriteHandlerTest, BubbleType)
-{
-    EXPECT_CALL(m_handler, onBubbleTypeChanged(Target::BubbleType::Say));
-    m_sprite.setBubbleType(Target::BubbleType::Say);
-
-    EXPECT_CALL(m_handler, onBubbleTypeChanged(Target::BubbleType::Think));
-    m_sprite.setBubbleType(Target::BubbleType::Think);
-}
-
-TEST_F(ISpriteHandlerTest, BubbleText)
-{
-    EXPECT_CALL(m_handler, onBubbleTextChanged("test"));
-    EXPECT_CALL(m_engine, requestRedraw());
-    m_sprite.setBubbleText("test");
-}
-
 TEST_F(ISpriteHandlerTest, BoundingRect)
 {
     EXPECT_CALL(m_handler, boundingRect()).WillOnce(Return(Rect(-44.6, 89.1, 20.5, -0.48)));
diff --git a/test/target_interfaces/istagehandler_test.cpp b/test/target_interfaces/istagehandler_test.cpp
index 242211ec..74c010dd 100644
--- a/test/target_interfaces/istagehandler_test.cpp
+++ b/test/target_interfaces/istagehandler_test.cpp
@@ -69,22 +69,6 @@ TEST_F(IStageHandlerTest, GraphicsEffects)
     m_stage.clearGraphicsEffects();
 }
 
-TEST_F(IStageHandlerTest, BubbleType)
-{
-    EXPECT_CALL(m_handler, onBubbleTypeChanged(Target::BubbleType::Say));
-    m_stage.setBubbleType(Target::BubbleType::Say);
-
-    EXPECT_CALL(m_handler, onBubbleTypeChanged(Target::BubbleType::Think));
-    m_stage.setBubbleType(Target::BubbleType::Think);
-}
-
-TEST_F(IStageHandlerTest, BubbleText)
-{
-    EXPECT_CALL(m_handler, onBubbleTextChanged("test"));
-    EXPECT_CALL(m_engine, requestRedraw());
-    m_stage.setBubbleText("test");
-}
-
 TEST_F(IStageHandlerTest, BoundingRect)
 {
     EXPECT_CALL(m_handler, boundingRect()).WillOnce(Return(Rect(-44.6, 89.1, 20.5, -0.48)));
diff --git a/test/thread/CMakeLists.txt b/test/thread/CMakeLists.txt
new file mode 100644
index 00000000..ae84dc1e
--- /dev/null
+++ b/test/thread/CMakeLists.txt
@@ -0,0 +1,14 @@
+add_executable(
+  thread_test
+  thread_test.cpp
+)
+
+target_link_libraries(
+  thread_test
+  GTest::gtest_main
+  GTest::gmock_main
+  scratchcpp
+  scratchcpp_mocks
+)
+
+gtest_discover_tests(thread_test)
diff --git a/test/thread/thread_test.cpp b/test/thread/thread_test.cpp
new file mode 100644
index 00000000..fb80cfe4
--- /dev/null
+++ b/test/thread/thread_test.cpp
@@ -0,0 +1,26 @@
+#include <scratchcpp/thread.h>
+#include <scratchcpp/script.h>
+#include <scratchcpp/virtualmachine.h>
+#include <targetmock.h>
+#include <enginemock.h>
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(ThreadTest, Constructor)
+{
+    TargetMock target;
+    EngineMock engine;
+    Script script(nullptr, nullptr, nullptr);
+    Thread thread(&target, &engine, &script);
+    ASSERT_EQ(thread.target(), &target);
+    ASSERT_EQ(thread.engine(), &engine);
+    ASSERT_EQ(thread.script(), &script);
+    ASSERT_TRUE(thread.vm());
+    ASSERT_EQ(thread.vm()->target(), &target);
+    ASSERT_EQ(thread.vm()->engine(), &engine);
+    ASSERT_EQ(thread.vm()->script(), &script);
+}
+
+// NOTE: Since VirtualMachine is going to be removed, tests for the other methods will be added later
diff --git a/test/virtual_machine/virtual_machine_test.cpp b/test/virtual_machine/virtual_machine_test.cpp
index 3a91c12c..a6e123f4 100644
--- a/test/virtual_machine/virtual_machine_test.cpp
+++ b/test/virtual_machine/virtual_machine_test.cpp
@@ -418,7 +418,7 @@ TEST(VirtualMachineTest, OP_RANDOM)
     static unsigned int bytecode8[] = { OP_START, OP_CONST, 6, OP_CONST, 7, OP_RANDOM, OP_HALT };
     static Value constValues[] = { -45, 12, 6.05, -78.686, "-45", "12", "6.05", "-78.686" };
 
-    VirtualMachinePrivate vm(nullptr, nullptr, nullptr, nullptr);
+    VirtualMachinePrivate vm(nullptr, nullptr, nullptr, nullptr, nullptr);
     vm.constValues = constValues;
 
     RandomGeneratorMock rng;
@@ -946,12 +946,12 @@ TEST(VirtualMachineTest, OP_READ_LIST)
 {
     static unsigned int bytecode[] = { OP_START, OP_READ_LIST, 0, OP_READ_LIST, 1, OP_HALT };
     List list1("", "list1");
-    list1.push_back(5.3);
-    list1.push_back("abc");
-    list1.push_back(false);
+    list1.append(5.3);
+    list1.append("abc");
+    list1.append(false);
     List list2("", "list2");
-    list2.push_back("t e s t");
-    list2.push_back(true);
+    list2.append("t e s t");
+    list2.append(true);
     List *lists[] = { &list1, &list2 };
 
     VirtualMachine vm;
@@ -978,10 +978,10 @@ TEST(VirtualMachineTest, OP_LIST_APPEND)
     vm.run();
 
     ASSERT_EQ(list1.size(), 1);
-    ASSERT_EQ(list1[0], 3.52);
+    ASSERT_EQ(Value(list1[0]), 3.52);
 
     ASSERT_EQ(list2.size(), 1);
-    ASSERT_EQ(list2[0], "test");
+    ASSERT_EQ(Value(list2[0]), "test");
 
     ASSERT_EQ(vm.registerCount(), 0);
 }
@@ -995,16 +995,16 @@ TEST(VirtualMachineTest, OP_LIST_DEL)
         0,        OP_CONST, 9,  OP_LIST_DEL, 0, OP_READ_LIST, 0, OP_CONST, 10, OP_LIST_DEL, 0, OP_READ_LIST, 0, OP_CONST, 11, OP_LIST_DEL, 0, OP_READ_LIST,
         0,        OP_CONST, 12, OP_LIST_DEL, 0, OP_READ_LIST, 0, OP_CONST, 13, OP_LIST_DEL, 0, OP_READ_LIST, 0, OP_HALT
     };
-    static Value constValues[] = { 3, 1, "6", 0, 7, -1, 9, Value::SpecialValue::NegativeInfinity, Value::SpecialValue::Infinity, Value::SpecialValue::NaN, "invalid", "last", "random", "all" };
+    static Value constValues[] = { 3, 1, "6", 0, 7, -1, 9, SpecialValue::NegativeInfinity, SpecialValue::Infinity, SpecialValue::NaN, "invalid", "last", "random", "all" };
     List list1("", "list1");
-    list1.push_back("a");
-    list1.push_back("b");
-    list1.push_back("c");
-    list1.push_back("d");
-    list1.push_back("e");
-    list1.push_back("f");
-    list1.push_back("g");
-    list1.push_back("h");
+    list1.append("a");
+    list1.append("b");
+    list1.append("c");
+    list1.append("d");
+    list1.append("e");
+    list1.append("f");
+    list1.append("g");
+    list1.append("h");
     List *lists[] = { &list1 };
 
     RandomGeneratorMock rng;
@@ -1041,11 +1041,11 @@ TEST(VirtualMachineTest, OP_LIST_DEL_ALL)
 {
     static unsigned int bytecode[] = { OP_START, OP_LIST_DEL_ALL, 0, OP_LIST_DEL_ALL, 1, OP_HALT };
     List list1("", "list1");
-    list1.push_back("a");
-    list1.push_back("b");
-    list1.push_back("c");
+    list1.append("a");
+    list1.append("b");
+    list1.append("c");
     List list2("", "list1");
-    list1.push_back("ab c");
+    list1.append("ab c");
     List *lists[] = { &list1, &list2 };
 
     VirtualMachine vm;
@@ -1067,16 +1067,16 @@ TEST(VirtualMachineTest, OP_LIST_INSERT)
         0,        OP_CONST,       0,  OP_CONST,       10, OP_LIST_INSERT, 0, OP_READ_LIST,   0, OP_CONST,       0,  OP_CONST,       11, OP_LIST_INSERT, 0, OP_READ_LIST,   0, OP_CONST,
         0,        OP_CONST,       12, OP_LIST_INSERT, 0,  OP_READ_LIST,   0, OP_CONST,       0, OP_CONST,       13, OP_LIST_INSERT, 0,  OP_READ_LIST,   0, OP_HALT
     };
-    static Value constValues[] = { "new item", "3", 1, 10, 0, 12, -1, 14, Value::SpecialValue::NegativeInfinity, Value::SpecialValue::Infinity, Value::SpecialValue::NaN, "last", "random", "invalid" };
+    static Value constValues[] = { "new item", "3", 1, 10, 0, 12, -1, 14, SpecialValue::NegativeInfinity, SpecialValue::Infinity, SpecialValue::NaN, "last", "random", "invalid" };
     List list1("", "list1");
-    list1.push_back("a");
-    list1.push_back("b");
-    list1.push_back("c");
-    list1.push_back("d");
-    list1.push_back("e");
-    list1.push_back("f");
-    list1.push_back("g");
-    list1.push_back("h");
+    list1.append("a");
+    list1.append("b");
+    list1.append("c");
+    list1.append("d");
+    list1.append("e");
+    list1.append("f");
+    list1.append("g");
+    list1.append("h");
     List *lists[] = { &list1 };
 
     RandomGeneratorMock rng;
@@ -1118,18 +1118,16 @@ TEST(VirtualMachineTest, OP_LIST_REPLACE)
         0,        OP_CONST,        10, OP_CONST,        0, OP_LIST_REPLACE, 0, OP_READ_LIST,    0,  OP_CONST,        11, OP_CONST,        11, OP_LIST_REPLACE, 0, OP_READ_LIST,    0, OP_CONST,
         12,       OP_CONST,        14, OP_LIST_REPLACE, 0, OP_READ_LIST,    0, OP_CONST,        13, OP_CONST,        0,  OP_LIST_REPLACE, 0,  OP_READ_LIST,    0, OP_HALT
     };
-    static Value constValues[] = {
-        "new item", 3, "1", 8, 0, 9, -1, 12, Value::SpecialValue::NegativeInfinity, Value::SpecialValue::Infinity, Value::SpecialValue::NaN, "last", "random", "invalid", "test"
-    };
+    static Value constValues[] = { "new item", 3, "1", 8, 0, 9, -1, 12, SpecialValue::NegativeInfinity, SpecialValue::Infinity, SpecialValue::NaN, "last", "random", "invalid", "test" };
     List list1("", "list1");
-    list1.push_back("a");
-    list1.push_back("b");
-    list1.push_back("c");
-    list1.push_back("d");
-    list1.push_back("e");
-    list1.push_back("f");
-    list1.push_back("g");
-    list1.push_back("h");
+    list1.append("a");
+    list1.append("b");
+    list1.append("c");
+    list1.append("d");
+    list1.append("e");
+    list1.append("f");
+    list1.append("g");
+    list1.append("h");
     List *lists[] = { &list1 };
 
     RandomGeneratorMock rng;
@@ -1168,16 +1166,16 @@ TEST(VirtualMachineTest, OP_LIST_GET_ITEM)
         0,        OP_CONST, 5,  OP_LIST_GET_ITEM, 0, OP_CONST, 6,  OP_LIST_GET_ITEM, 0, OP_CONST, 7,  OP_LIST_GET_ITEM, 0, OP_CONST, 8, OP_LIST_GET_ITEM, 0, OP_CONST, 9, OP_LIST_GET_ITEM,
         0,        OP_CONST, 10, OP_LIST_GET_ITEM, 0, OP_CONST, 11, OP_LIST_GET_ITEM, 0, OP_CONST, 12, OP_LIST_GET_ITEM, 0, OP_HALT
     };
-    static Value constValues[] = { 3, 1, "8", 0, 9, -1, 12, Value::SpecialValue::NegativeInfinity, Value::SpecialValue::Infinity, Value::SpecialValue::NaN, "last", "random", "invalid" };
+    static Value constValues[] = { 3, 1, "8", 0, 9, -1, 12, SpecialValue::NegativeInfinity, SpecialValue::Infinity, SpecialValue::NaN, "last", "random", "invalid" };
     List list1("", "list1");
-    list1.push_back("a");
-    list1.push_back("b");
-    list1.push_back("c");
-    list1.push_back("d");
-    list1.push_back("e");
-    list1.push_back("f");
-    list1.push_back("g");
-    list1.push_back("h");
+    list1.append("a");
+    list1.append("b");
+    list1.append("c");
+    list1.append("d");
+    list1.append("e");
+    list1.append("f");
+    list1.append("g");
+    list1.append("h");
     List *lists[] = { &list1 };
 
     RandomGeneratorMock rng;
@@ -1215,16 +1213,16 @@ TEST(VirtualMachineTest, OP_LIST_INDEX_OF)
         OP_START, OP_CONST,         0, OP_LIST_INDEX_OF, 0, OP_CONST,         1, OP_LIST_INDEX_OF, 0, OP_CONST,         2, OP_LIST_INDEX_OF, 0, OP_CONST,         3, OP_LIST_INDEX_OF, 0, OP_CONST,
         4,        OP_LIST_INDEX_OF, 0, OP_CONST,         5, OP_LIST_INDEX_OF, 0, OP_CONST,         6, OP_LIST_INDEX_OF, 0, OP_CONST,         7, OP_LIST_INDEX_OF, 0, OP_HALT
     };
-    static Value constValues[] = { "c", "A", "e", "", "invalid", Value::SpecialValue::NegativeInfinity, Value::SpecialValue::Infinity, Value::SpecialValue::NaN };
+    static Value constValues[] = { "c", "A", "e", "", "invalid", SpecialValue::NegativeInfinity, SpecialValue::Infinity, SpecialValue::NaN };
     List list1("", "list1");
-    list1.push_back("a");
-    list1.push_back("b");
-    list1.push_back("c");
-    list1.push_back("d");
-    list1.push_back("e");
-    list1.push_back("");
-    list1.push_back(Value::SpecialValue::Infinity);
-    list1.push_back(8);
+    list1.append("a");
+    list1.append("b");
+    list1.append("c");
+    list1.append("d");
+    list1.append("e");
+    list1.append("");
+    list1.append(SpecialValue::Infinity);
+    list1.append(8);
     List *lists[] = { &list1 };
 
     VirtualMachine vm;
@@ -1247,12 +1245,12 @@ TEST(VirtualMachineTest, OP_LIST_LENGTH)
 {
     static unsigned int bytecode[] = { OP_START, OP_LIST_LENGTH, 0, OP_LIST_LENGTH, 1, OP_HALT };
     List list1("", "list1");
-    list1.push_back("a");
-    list1.push_back("b");
-    list1.push_back("c");
-    list1.push_back("d");
+    list1.append("a");
+    list1.append("b");
+    list1.append("c");
+    list1.append("d");
     List list2("", "list2");
-    list2.push_back("a");
+    list2.append("a");
     List *lists[] = { &list1, &list2 };
 
     VirtualMachine vm;
@@ -1270,16 +1268,16 @@ TEST(VirtualMachineTest, OP_LIST_CONTAINS)
         OP_START, OP_CONST,         0, OP_LIST_CONTAINS, 0, OP_CONST,         1, OP_LIST_CONTAINS, 0, OP_CONST,         2, OP_LIST_CONTAINS, 0, OP_CONST,         3, OP_LIST_CONTAINS, 0, OP_CONST,
         4,        OP_LIST_CONTAINS, 0, OP_CONST,         5, OP_LIST_CONTAINS, 0, OP_CONST,         6, OP_LIST_CONTAINS, 0, OP_CONST,         7, OP_LIST_CONTAINS, 0, OP_HALT
     };
-    static Value constValues[] = { "c", "A", "e", "", "invalid", Value::SpecialValue::NegativeInfinity, Value::SpecialValue::Infinity, Value::SpecialValue::NaN };
+    static Value constValues[] = { "c", "A", "e", "", "invalid", SpecialValue::NegativeInfinity, SpecialValue::Infinity, SpecialValue::NaN };
     List list1("", "list1");
-    list1.push_back("a");
-    list1.push_back("b");
-    list1.push_back("c");
-    list1.push_back("d");
-    list1.push_back("e");
-    list1.push_back("");
-    list1.push_back(Value::SpecialValue::Infinity);
-    list1.push_back(8);
+    list1.append("a");
+    list1.append("b");
+    list1.append("c");
+    list1.append("d");
+    list1.append("e");
+    list1.append("");
+    list1.append(SpecialValue::Infinity);
+    list1.append(8);
     List *lists[] = { &list1 };
 
     VirtualMachine vm;
@@ -1301,7 +1299,7 @@ TEST(VirtualMachineTest, OP_LIST_CONTAINS)
 TEST(VirtualMachineTest, OP_STR_CONCAT)
 {
     static unsigned int bytecode[] = { OP_START, OP_CONST, 0, OP_CONST, 1, OP_STR_CONCAT, OP_CONST, 2, OP_STR_CONCAT, OP_CONST, 3, OP_STR_CONCAT, OP_HALT };
-    static Value constValues[] = { "abc ", "def", " ghi", Value::SpecialValue::NegativeInfinity };
+    static Value constValues[] = { "abc ", "def", " ghi", SpecialValue::NegativeInfinity };
 
     VirtualMachine vm;
     vm.setBytecode(bytecode);
@@ -1318,9 +1316,7 @@ TEST(VirtualMachineTest, OP_STR_AT)
         OP_STR_AT, OP_CONST, 0, OP_CONST, 6,  OP_STR_AT, OP_CONST, 0, OP_CONST, 7,  OP_STR_AT, OP_CONST, 0, OP_CONST, 8,  OP_STR_AT, OP_CONST, 0, OP_CONST, 9, OP_STR_AT, OP_CONST, 0, OP_CONST, 10,
         OP_STR_AT, OP_CONST, 0, OP_CONST, 11, OP_STR_AT, OP_CONST, 0, OP_CONST, 12, OP_STR_AT, OP_CONST, 0, OP_CONST, 13, OP_STR_AT, OP_HALT
     };
-    static Value constValues[] = {
-        "abcd efg  hijý", 3, 1, 14, 0, 15, -1, 16, Value::SpecialValue::NegativeInfinity, Value::SpecialValue::Infinity, Value::SpecialValue::NaN, "last", "random", "invalid"
-    };
+    static Value constValues[] = { "abcd efg  hijý", 3, 1, 14, 0, 15, -1, 16, SpecialValue::NegativeInfinity, SpecialValue::Infinity, SpecialValue::NaN, "last", "random", "invalid" };
 
     VirtualMachine vm;
     vm.setBytecode(bytecode);