diff --git a/CMakeLists.txt b/CMakeLists.txt
index deeb6780..0f9fcc13 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -31,7 +31,6 @@ 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
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/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 48498790..f4938a3c 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -14,7 +14,7 @@
 namespace libscratchcpp
 {
 
-class IBlockSection;
+class IExtension;
 class Broadcast;
 class Block;
 class Target;
@@ -217,12 +217,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;
 
@@ -230,53 +224,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;
@@ -381,11 +375,13 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Emits when a question is answered. */
         virtual sigslot::signal<const std::string &> &questionAnswered() = 0;
 
+#ifndef USE_LLVM
         /*! Returns the list of extension names. */
         virtual const std::vector<std::string> &extensions() const = 0;
 
         /*! Sets the list of extension names. */
         virtual void setExtensions(const std::vector<std::string> &newExtensions) = 0;
+#endif
 
         /*! Returns the map of scripts (each top level block has a Script object). */
         virtual const std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> &scripts() const = 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/monitor.h b/include/scratchcpp/monitor.h
index cabc16c0..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);
diff --git a/include/scratchcpp/scratchconfiguration.h b/include/scratchcpp/scratchconfiguration.h
index dd58ea33..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. */
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 6ae35901..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
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 82f9feb1..576711c0 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
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
index f09b3f2b..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;
 
diff --git a/src/blocks/listblocks.cpp b/src/blocks/listblocks.cpp
index b88ab1f3..135dd0bd 100644
--- a/src/blocks/listblocks.cpp
+++ b/src/blocks/listblocks.cpp
@@ -18,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)
diff --git a/src/blocks/listblocks.h b/src/blocks/listblocks.h
index 8fcf7b7f..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;
 
diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index ca14f367..8abb9688 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -37,6 +37,11 @@ std::string LooksBlocks::name() const
     return "Looks";
 }
 
+std::string LooksBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void LooksBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
diff --git a/src/blocks/looksblocks.h b/src/blocks/looksblocks.h
index 2c3adc2a..6a6148f6 100644
--- a/src/blocks/looksblocks.h
+++ b/src/blocks/looksblocks.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include <scratchcpp/iblocksection.h>
+#include <scratchcpp/iextension.h>
 #include <scratchcpp/target.h>
 #include <vector>
 #include <unordered_map>
@@ -17,8 +17,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 +58,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;
diff --git a/src/blocks/motionblocks.cpp b/src/blocks/motionblocks.cpp
index fd2991ac..c5a96004 100644
--- a/src/blocks/motionblocks.cpp
+++ b/src/blocks/motionblocks.cpp
@@ -24,6 +24,11 @@ std::string MotionBlocks::name() const
     return "Motion";
 }
 
+std::string MotionBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void MotionBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
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 b713ae6a..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
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 b13f9309..bd3acbb0 100644
--- a/src/blocks/sensingblocks.cpp
+++ b/src/blocks/sensingblocks.cpp
@@ -28,6 +28,11 @@ std::string SensingBlocks::name() const
     return "Sensing";
 }
 
+std::string SensingBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void SensingBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
diff --git a/src/blocks/sensingblocks.h b/src/blocks/sensingblocks.h
index 1d7e1903..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,7 +15,7 @@ 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
@@ -59,6 +59,7 @@ class SensingBlocks : 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/soundblocks.cpp b/src/blocks/soundblocks.cpp
index 1f34e27f..6cc2aa7b 100644
--- a/src/blocks/soundblocks.cpp
+++ b/src/blocks/soundblocks.cpp
@@ -29,6 +29,11 @@ std::string SoundBlocks::name() const
     return "Sound";
 }
 
+std::string SoundBlocks::description() const
+{
+    return name() + " blocks";
+}
+
 void SoundBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
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 88b296d2..81961e49 100644
--- a/src/blocks/variableblocks.cpp
+++ b/src/blocks/variableblocks.cpp
@@ -18,6 +18,11 @@ std::string VariableBlocks::name() const
     return "Variables";
 }
 
+std::string VariableBlocks::description() const
+{
+    return "Variable blocks";
+}
+
 void VariableBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
diff --git a/src/blocks/variableblocks.h b/src/blocks/variableblocks.h
index 27ecf99b..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;
 
diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
index 66f24e61..755e771f 100644
--- a/src/engine/CMakeLists.txt
+++ b/src/engine/CMakeLists.txt
@@ -19,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 a877528f..b39e9115 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -1,7 +1,7 @@
 // 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>
@@ -24,11 +24,10 @@
 #include <iostream>
 
 #include "engine.h"
-#include "blocksectioncontainer.h"
 #include "timer.h"
 #include "clock.h"
 #include "audio/iaudioengine.h"
-#include "blocks/standardblocks.h"
+#include "blocks/blocks.h"
 #include "scratch/monitor_p.h"
 
 using namespace libscratchcpp;
@@ -69,7 +68,6 @@ void Engine::clear()
             m_threadAboutToStop(thread.get());
     }
 
-    m_sections.clear();
     m_targets.clear();
     m_broadcasts.clear();
     m_monitors.clear();
@@ -106,21 +104,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 +149,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 +189,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 +209,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 +266,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;
 
@@ -926,30 +924,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);
@@ -964,68 +938,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
@@ -1423,18 +1397,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();
 
-    // Register block sections of extensions
+    for (auto ext : defaultExtensions)
+        ext->registerBlocks(this);
+
+    // 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;
     }
 }
@@ -1610,17 +1588,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)
@@ -1704,43 +1671,161 @@ void Engine::updateSpriteLayerOrder()
         m_executableTargets[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)
@@ -1748,20 +1833,17 @@ 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 section = blockSection(block->opcode());
-    auto container = blockSectionContainer(block->opcode());
+    auto ext = blockExtension(block->opcode());
 
-    if (container) {
-        MonitorNameFunc nameFunc = container->resolveMonitorNameFunc(block->opcode());
+    if (ext) {
+        MonitorNameFunc nameFunc = resolveMonitorNameFunc(ext, block->opcode());
 
         if (nameFunc)
             monitor->setName(nameFunc(block.get()));
 
-        MonitorChangeFunc changeFunc = container->resolveMonitorChangeFunc(block->opcode());
+        MonitorChangeFunc changeFunc = resolveMonitorChangeFunc(ext, block->opcode());
         monitor->setValueChangeFunction(changeFunc);
-    }
 
-    if (section) {
         auto script = std::make_shared<Script>(target, block, this);
         monitor->setScript(script);
         compiler.init();
@@ -1837,16 +1919,16 @@ void Engine::addVarOrListMonitor(std::shared_ptr<Monitor> monitor, Target *targe
     if (!target->isStage())
         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);
     }
 
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index cbd1904c..a5242b54 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -12,8 +12,6 @@
 #include <set>
 #include <variant>
 
-#include "blocksectioncontainer.h"
-
 namespace libscratchcpp
 {
 
@@ -104,19 +102,17 @@ class Engine : public IEngine
         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;
@@ -163,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;
 
@@ -195,6 +188,16 @@ class Engine : public IEngine
             WhenGreaterThanMenu
         };
 
+        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();
@@ -210,7 +213,6 @@ 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);
@@ -235,7 +237,6 @@ class Engine : public IEngine
         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;
@@ -252,6 +253,14 @@ class Engine : public IEngine
         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;
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/monitor.cpp b/src/scratch/monitor.cpp
index ac85586a..10a037a0 100644
--- a/src/scratch/monitor.cpp
+++ b/src/scratch/monitor.cpp
@@ -78,18 +78,18 @@ 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(). */
diff --git a/src/scratch/monitor_p.h b/src/scratch/monitor_p.h
index 43384155..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;
diff --git a/src/scratchconfiguration.cpp b/src/scratchconfiguration.cpp
index f67706ef..96ea1468 100644
--- a/src/scratchconfiguration.cpp
+++ b/src/scratchconfiguration.cpp
@@ -5,7 +5,6 @@
 #include <iostream>
 
 #include "scratchconfiguration_p.h"
-#include "blocks/standardblocks.h"
 
 using namespace libscratchcpp;
 
@@ -15,6 +14,12 @@ void ScratchConfiguration::registerExtension(std::shared_ptr<IExtension> extensi
     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)
 {
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/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 ca56a705..a7166826 100644
--- a/test/blocks/control_blocks_test.cpp
+++ b/test/blocks/control_blocks_test.cpp
@@ -25,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
@@ -132,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)
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 28365ed7..43d83dec 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -28,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 });
@@ -118,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;
@@ -126,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)
diff --git a/test/blocks/list_blocks_test.cpp b/test/blocks/list_blocks_test.cpp
index 8c3c946e..90577da8 100644
--- a/test/blocks/list_blocks_test.cpp
+++ b/test/blocks/list_blocks_test.cpp
@@ -21,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
@@ -81,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)
diff --git a/test/blocks/looks_blocks_test.cpp b/test/blocks/looks_blocks_test.cpp
index f34152a1..c5fa40ef 100644
--- a/test/blocks/looks_blocks_test.cpp
+++ b/test/blocks/looks_blocks_test.cpp
@@ -28,8 +28,8 @@ 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
@@ -90,82 +90,77 @@ 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));
 
     // 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)
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 711b6b52..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)
diff --git a/test/blocks/sensing_blocks_test.cpp b/test/blocks/sensing_blocks_test.cpp
index d5afbde1..03d74fc8 100644
--- a/test/blocks/sensing_blocks_test.cpp
+++ b/test/blocks/sensing_blocks_test.cpp
@@ -30,8 +30,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 +100,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,85 +114,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_coloristouchingcolor", &SensingBlocks::compileColorIsTouchingColor));
-    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(), "COLOR2", SensingBlocks::COLOR2));
-    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);
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 f772476a..8d50aefd 100644
--- a/test/blocks/variable_blocks_test.cpp
+++ b/test/blocks/variable_blocks_test.cpp
@@ -21,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
@@ -54,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)
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 edfac2db..cbb91a89 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -9,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;                                                                                                                                                                                 \
@@ -37,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)
@@ -343,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);
 
@@ -362,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);
 
@@ -406,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);
 
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 39d35eff..758bad31 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -12,6 +12,7 @@
 #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>
@@ -21,7 +22,7 @@
 #include <audioplayermock.h>
 #include <audioloudnessmock.h>
 #include <monitorhandlermock.h>
-#include <blocksectionmock.h>
+#include <extensionmock.h>
 #include <thread>
 
 #include "../common.h"
@@ -79,10 +80,12 @@ TEST(EngineTest, Clear)
     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>("", "");
@@ -101,7 +104,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);
@@ -114,6 +117,8 @@ TEST(EngineTest, Clear)
     EXPECT_CALL(removeMonitorMock, monitorRemoved(monitor4.get(), &iface4));
     engine.clear();
     ASSERT_TRUE(engine.monitors().empty());
+
+    ScratchConfiguration::removeExtension(extension);
 }
 
 TEST(EngineTest, ClearThreadAboutToStopSignal)
@@ -202,22 +207,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();
@@ -234,9 +241,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());
@@ -270,6 +277,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)
@@ -958,32 +967,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 *)
@@ -1008,265 +1012,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;
@@ -2043,8 +1788,6 @@ TEST(EngineTest, StopAllBypass)
     ASSERT_VAR(stage, "j");
     ASSERT_EQ(GET_VAR(stage, "j")->value().toInt(), 5);
 
-    ASSERT_TRUE(engine->isRunning());
-    engine->step();
     ASSERT_FALSE(engine->isRunning());
 }
 
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/mocks/enginemock.h b/test/mocks/enginemock.h
index 29664032..65e24eb5 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -84,18 +84,17 @@ class EngineMock : public IEngine
 
         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));
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/scratch_classes/CMakeLists.txt b/test/scratch_classes/CMakeLists.txt
index f7ab3cfd..6fecf4a2 100644
--- a/test/scratch_classes/CMakeLists.txt
+++ b/test/scratch_classes/CMakeLists.txt
@@ -222,8 +222,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/monitor_test.cpp b/test/scratch_classes/monitor_test.cpp
index 0df1f728..4080703e 100644
--- a/test/scratch_classes/monitor_test.cpp
+++ b/test/scratch_classes/monitor_test.cpp
@@ -8,7 +8,7 @@
 #include <randomgeneratormock.h>
 
 #include "../common.h"
-#include "testsection.h"
+#include "testextension.h"
 
 using namespace libscratchcpp;
 
@@ -84,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)
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/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)