diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 0d9d8fca..c6d2312a 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -15,6 +15,9 @@ class IBlockSection;
 class Broadcast;
 class Block;
 class Target;
+class Sprite;
+class Variable;
+class List;
 class Script;
 
 /*!
@@ -70,6 +73,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
          */
         virtual void stopTarget(Target *target, VirtualMachine *exceptScript) = 0;
 
+        /*! Calls the "when I start as a clone" blocks of the given sprite. */
+        virtual void initClone(Sprite *clone) = 0;
+
         /*!
          * Runs the event loop and calls "when green flag clicked" blocks.
          * \note This function returns when all scripts finish.\n
@@ -157,6 +163,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Registers the broadcast script. */
         virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::shared_ptr<Broadcast> broadcast) = 0;
 
+        /* Registers the given "when I start as clone" script. */
+        virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
+
         /*! Returns the list of targets. */
         virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;
 
@@ -169,6 +178,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the index of the target with the given name. */
         virtual int findTarget(const std::string &targetName) const = 0;
 
+        /*! Returns the target which owns the given variable. If it is the stage, the variable is global. */
+        virtual Target *variableOwner(Variable *variable) const = 0;
+
+        /*! Returns the target which owns the given list. If it is the stage, the list is global. */
+        virtual Target *listOwner(List *list) const = 0;
+
         /*! Returns the list of extension names. */
         virtual const std::vector<std::string> &extensions() const = 0;
 
diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index 8090d603..78afd2d4 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -15,6 +15,7 @@ class Target;
 class IEngine;
 class Value;
 class VirtualMachine;
+class Variable;
 class List;
 class ScriptPrivate;
 
@@ -25,6 +26,8 @@ class LIBSCRATCHCPP_EXPORT Script
         Script(Target *target, IEngine *engine);
         Script(const Script &) = delete;
 
+        Target *target() const;
+
         unsigned int *bytecode() const;
         const std::vector<unsigned int> &bytecodeVector() const;
         void setBytecode(const std::vector<unsigned int> &code);
@@ -32,10 +35,11 @@ class LIBSCRATCHCPP_EXPORT Script
         void setProcedures(const std::vector<unsigned int *> &procedures);
         void setFunctions(const std::vector<BlockFunc> &functions);
         void setConstValues(const std::vector<Value> &values);
-        void setVariables(const std::vector<Value *> &variables);
+        void setVariables(const std::vector<Variable *> &variables);
         void setLists(const std::vector<List *> &lists);
 
         std::shared_ptr<VirtualMachine> start();
+        std::shared_ptr<VirtualMachine> start(Target *target);
 
     private:
         spimpl::unique_impl_ptr<ScriptPrivate> impl;
diff --git a/include/scratchcpp/sprite.h b/include/scratchcpp/sprite.h
index d9ede3d5..dd50f56e 100644
--- a/include/scratchcpp/sprite.h
+++ b/include/scratchcpp/sprite.h
@@ -22,9 +22,19 @@ class LIBSCRATCHCPP_EXPORT Sprite : public Target
         };
 
         Sprite();
+        ~Sprite();
 
         void setInterface(ISpriteHandler *newInterface);
 
+        std::shared_ptr<Sprite> clone();
+
+        bool isClone() const;
+
+        Sprite *cloneRoot() const;
+        Sprite *cloneParent() const;
+        const std::vector<std::shared_ptr<Sprite>> &children() const;
+        std::vector<std::shared_ptr<Sprite>> allChildren() const;
+
         bool visible() const;
         void setVisible(bool newVisible);
 
@@ -50,6 +60,8 @@ class LIBSCRATCHCPP_EXPORT Sprite : public Target
         void setRotationStyle(const char *newRotationStyle);
 
     private:
+        Target *dataSource() const override;
+
         spimpl::unique_impl_ptr<SpritePrivate> impl;
 };
 
diff --git a/include/scratchcpp/target.h b/include/scratchcpp/target.h
index 3a9b01a7..fe9e7e23 100644
--- a/include/scratchcpp/target.h
+++ b/include/scratchcpp/target.h
@@ -10,6 +10,7 @@
 namespace libscratchcpp
 {
 
+class IEngine;
 class Variable;
 class List;
 class Block;
@@ -67,6 +68,13 @@ class LIBSCRATCHCPP_EXPORT Target
         int volume() const;
         void setVolume(int newVolume);
 
+        IEngine *engine() const;
+        void setEngine(IEngine *engine);
+
+    protected:
+        /*! Override this method to set a custom data source for blocks and assets. */
+        virtual Target *dataSource() const { return nullptr; }
+
     private:
         spimpl::unique_impl_ptr<TargetPrivate> impl;
 };
diff --git a/include/scratchcpp/virtualmachine.h b/include/scratchcpp/virtualmachine.h
index 0e262cff..41dd40ea 100644
--- a/include/scratchcpp/virtualmachine.h
+++ b/include/scratchcpp/virtualmachine.h
@@ -102,6 +102,8 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
         void setConstValues(const Value *values);
         void setVariables(Value **variables);
         void setLists(List **lists);
+        void setVariablesVector(const std::vector<Value *> &variables);
+        void setListsVector(const std::vector<List *> &lists);
 
         void setBytecode(unsigned int *code);
 
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 2eefcca0..3572e4fa 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/scratchconfiguration.h>
 #include <scratchcpp/iblocksection.h>
 #include <scratchcpp/script.h>
+#include <scratchcpp/sprite.h>
 #include <scratchcpp/broadcast.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/input.h>
@@ -111,7 +112,7 @@ void Engine::compile()
             if (m_scripts.count(block) == 1) {
                 m_scripts[block]->setProcedures(procedureBytecodes);
                 m_scripts[block]->setConstValues(compiler.constValues());
-                m_scripts[block]->setVariables(compiler.variablePtrs());
+                m_scripts[block]->setVariables(compiler.variables());
                 m_scripts[block]->setLists(compiler.lists());
             }
         }
@@ -201,22 +202,21 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
     const std::vector<Script *> &scripts = m_broadcastMap[index];
 
     for (auto script : scripts) {
-        long scriptIndex = -1;
-        for (long i = 0; i < m_runningScripts.size(); i++) {
-            if (m_runningScripts[i]->script() == script) {
-                scriptIndex = i;
-                break;
+        std::vector<VirtualMachine *> runningBroadcastScripts;
+
+        for (auto vm : m_runningScripts) {
+            if (vm->script() == script) {
+                runningBroadcastScripts.push_back(vm.get());
             }
         }
 
-        if (scriptIndex != -1) {
-            // Reset the script if it's already running
-            auto vm = m_runningScripts[scriptIndex];
+        // Reset running scripts
+        for (VirtualMachine *vm : runningBroadcastScripts) {
             vm->reset();
 
             // Remove the script from scripts to remove because it's going to run again
-            m_scriptsToRemove.erase(std::remove(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm.get()), m_scriptsToRemove.end());
-            assert(std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), m_runningScripts[scriptIndex].get()) == m_scriptsToRemove.end());
+            m_scriptsToRemove.erase(std::remove(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm), m_scriptsToRemove.end());
+            assert(std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm) == m_scriptsToRemove.end());
 
             auto &scripts = m_runningBroadcastMap[index];
 
@@ -232,10 +232,29 @@ void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wa
                     m_skipFrame = false;
             } else
                 sourceScript->stop(true, true);
-        } else {
-            auto vm = script->start();
-            m_runningScripts.push_back(vm);
-            m_runningBroadcastMap[index].push_back({ sourceScript, vm.get() });
+        }
+
+        // Start scripts which are not running
+        Target *root = script->target();
+        std::vector<Target *> targets = { root };
+
+        if (!root->isStage()) {
+            Sprite *sprite = dynamic_cast<Sprite *>(root);
+            assert(sprite);
+            auto children = sprite->allChildren();
+
+            for (auto child : children)
+                targets.push_back(child.get());
+        }
+
+        for (Target *target : targets) {
+            auto it = std::find_if(runningBroadcastScripts.begin(), runningBroadcastScripts.end(), [target](VirtualMachine *vm) { return vm->target() == target; });
+
+            if (it == runningBroadcastScripts.end()) {
+                auto vm = script->start(target);
+                m_runningScripts.push_back(vm);
+                m_runningBroadcastMap[index].push_back({ sourceScript, vm.get() });
+            }
         }
     }
 }
@@ -258,6 +277,37 @@ void Engine::stopTarget(Target *target, VirtualMachine *exceptScript)
         stopScript(script);
 }
 
+void Engine::initClone(Sprite *clone)
+{
+    if (!clone)
+        return;
+
+    Sprite *source = clone->cloneParent();
+    Target *root = clone->cloneRoot();
+    assert(source);
+    assert(root);
+
+    if (!source || !root)
+        return;
+
+    auto it = m_cloneInitScriptsMap.find(root);
+
+    if (it != m_cloneInitScriptsMap.cend()) {
+        const auto &scripts = it->second;
+
+#ifndef NDEBUG
+        // Since we're initializing the clone, it shouldn't have any running scripts
+        for (const auto script : m_runningScripts)
+            assert(script->target() != clone);
+#endif
+
+        for (auto script : scripts) {
+            auto vm = script->start(clone);
+            m_runningScripts.push_back(vm);
+        }
+    }
+}
+
 void Engine::run()
 {
     auto frameDuration = std::chrono::milliseconds(33);
@@ -442,6 +492,7 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::s
     auto id = findBroadcast(broadcast->name());
     if (m_broadcastMap.count(id) == 1) {
         std::vector<Script *> &scripts = m_broadcastMap[id];
+        // TODO: Do not allow adding existing scripts
         scripts.push_back(m_scripts[whenReceivedBlock].get());
     } else {
         m_broadcastMap[id] = { m_scripts[whenReceivedBlock].get() };
@@ -452,6 +503,22 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::s
     }
 }
 
+void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
+{
+    Target *target = hatBlock->target();
+    Script *script = m_scripts[hatBlock].get();
+    auto it = m_cloneInitScriptsMap.find(target);
+
+    if (it == m_cloneInitScriptsMap.cend())
+        m_cloneInitScriptsMap[target] = { m_scripts[hatBlock].get() };
+    else {
+        auto &scripts = it->second;
+
+        if (std::find(scripts.begin(), scripts.end(), script) == scripts.cend())
+            scripts.push_back(script);
+    }
+}
+
 const std::vector<std::shared_ptr<Target>> &Engine::targets() const
 {
     return m_targets;
@@ -460,14 +527,31 @@ const std::vector<std::shared_ptr<Target>> &Engine::targets() const
 void Engine::setTargets(const std::vector<std::shared_ptr<Target>> &newTargets)
 {
     m_targets = newTargets;
+    m_variableOwners.clear();
+    m_listOwners.clear();
 
-    // Set engine and target in all blocks
     for (auto target : m_targets) {
+        // Set engine in the target
+        target->setEngine(this);
         auto blocks = target->blocks();
+
         for (auto block : blocks) {
+            // Set engine and target in the block
             block->setEngine(this);
             block->setTarget(target.get());
         }
+
+        // Add variables to owner map
+        const auto &variables = target->variables();
+
+        for (auto variable : variables)
+            m_variableOwners[variable.get()] = target.get();
+
+        // Add lists to owner map
+        const auto &lists = target->lists();
+
+        for (auto list : lists)
+            m_listOwners[list.get()] = target.get();
     }
 }
 
@@ -490,6 +574,26 @@ int Engine::findTarget(const std::string &targetName) const
     return -1;
 }
 
+Target *Engine::variableOwner(Variable *variable) const
+{
+    auto it = m_variableOwners.find(variable);
+
+    if (it == m_variableOwners.cend())
+        return nullptr;
+
+    return it->second;
+}
+
+Target *Engine::listOwner(List *list) const
+{
+    auto it = m_listOwners.find(list);
+
+    if (it == m_listOwners.cend())
+        return nullptr;
+
+    return it->second;
+}
+
 const std::vector<std::string> &Engine::extensions() const
 {
     return m_extensions;
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 6dd5f316..06980bbc 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -32,6 +32,7 @@ class Engine : public IEngine
         void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) override;
         void stopScript(VirtualMachine *vm) override;
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
+        void initClone(libscratchcpp::Sprite *clone) override;
         void run() override;
 
         bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) override;
@@ -60,11 +61,16 @@ class Engine : public IEngine
 
         void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, std::shared_ptr<Broadcast> broadcast) override;
 
+        void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
+
         const std::vector<std::shared_ptr<Target>> &targets() const override;
         void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) override;
         Target *targetAt(int index) const override;
         int findTarget(const std::string &targetName) const override;
 
+        Target *variableOwner(Variable *variable) const override;
+        Target *listOwner(List *list) const override;
+
         const std::vector<std::string> &extensions() const override;
         void setExtensions(const std::vector<std::string> &newExtensions) override;
 
@@ -86,11 +92,14 @@ class Engine : public IEngine
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::unordered_map<unsigned int, std::vector<Script *>> m_broadcastMap;
         std::unordered_map<unsigned int, std::vector<std::pair<VirtualMachine *, VirtualMachine *>>> m_runningBroadcastMap; // source script, "when received" script
+        std::unordered_map<Target *, std::vector<Script *>> m_cloneInitScriptsMap;                                          // target (no clones), "when I start as a clone" scripts
         std::vector<std::string> m_extensions;
         std::vector<std::shared_ptr<VirtualMachine>> m_runningScripts;
         std::vector<VirtualMachine *> m_scriptsToRemove;
         std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> m_scripts;
         std::vector<BlockFunc> m_functions;
+        std::unordered_map<Variable *, Target *> m_variableOwners;
+        std::unordered_map<List *, Target *> m_listOwners;
 
         bool m_breakFrame = false;
         bool m_skipFrame = false;
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index a6739fe9..14e2c9e1 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -2,6 +2,11 @@
 
 #include <scratchcpp/script.h>
 #include <scratchcpp/virtualmachine.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
+#include <scratchcpp/sprite.h>
+#include <scratchcpp/iengine.h>
+#include <iostream>
 
 #include "script_p.h"
 
@@ -13,6 +18,12 @@ Script::Script(Target *target, IEngine *engine) :
 {
 }
 
+/*! Returns the Target. */
+Target *Script::target() const
+{
+    return impl->target;
+}
+
 /*! Returns the bytecode array. */
 unsigned int *Script::bytecode() const
 {
@@ -35,13 +46,69 @@ void Script::setBytecode(const std::vector<unsigned int> &code)
 /*! Starts the script (creates a virtual machine). */
 std::shared_ptr<VirtualMachine> Script::start()
 {
-    auto vm = std::make_shared<VirtualMachine>(impl->target, impl->engine, this);
+    return start(impl->target);
+}
+
+/*! Starts the script (creates a virtual machine) as the given target (might be a clone). */
+std::shared_ptr<VirtualMachine> Script::start(Target *target)
+{
+    auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
     vm->setBytecode(impl->bytecode);
     vm->setProcedures(impl->procedures);
     vm->setFunctions(impl->functions);
     vm->setConstValues(impl->constValues);
-    vm->setVariables(impl->variables);
-    vm->setLists(impl->lists);
+
+    Sprite *sprite = nullptr;
+    if (target && !target->isStage())
+        sprite = dynamic_cast<Sprite *>(target);
+
+    if (impl->target && sprite && sprite->isClone() && impl->engine) {
+        Target *root = sprite->cloneRoot();
+
+        if (root != impl->target) {
+            std::cout << "warning: a clone tried to start a script of another target (this is a bug in libscratchcpp or in your code!)" << std::endl;
+            vm->setVariables(impl->variableValues.data());
+            vm->setLists(impl->lists.data());
+            return vm;
+        }
+
+        // Use internal variables and lists from the clone
+        std::vector<Value *> variables;
+        std::vector<List *> lists;
+
+        for (const auto &var : impl->variables) {
+            Target *owner = impl->engine->variableOwner(var);
+
+            if (owner && (owner == root)) {
+                auto cloneVar = sprite->variableAt(sprite->findVariableById(var->id()));
+                assert(cloneVar);
+
+                if (cloneVar)
+                    variables.push_back(cloneVar->valuePtr());
+            } else
+                variables.push_back(var->valuePtr());
+        }
+
+        for (const auto &list : impl->lists) {
+            Target *owner = impl->engine->listOwner(list);
+
+            if (owner && (owner == root)) {
+                auto cloneList = sprite->listAt(sprite->findListById(list->id()));
+                assert(cloneList);
+
+                if (cloneList)
+                    lists.push_back(cloneList.get());
+            } else
+                lists.push_back(list);
+        }
+
+        vm->setVariablesVector(variables);
+        vm->setListsVector(lists);
+    } else {
+        vm->setVariables(impl->variableValues.data());
+        vm->setLists(impl->lists.data());
+    }
+
     return vm;
 }
 
@@ -67,15 +134,17 @@ void Script::setConstValues(const std::vector<Value> &values)
 }
 
 /*! Sets the list of variables. */
-void Script::setVariables(const std::vector<Value *> &variables)
+void Script::setVariables(const std::vector<Variable *> &variables)
 {
-    impl->variablesVector = variables;
-    impl->variables = impl->variablesVector.data();
+    impl->variables = variables;
+    impl->variableValues.clear();
+
+    for (const auto &var : variables)
+        impl->variableValues.push_back(var->valuePtr());
 }
 
 /*! Sets the list of lists. */
 void Script::setLists(const std::vector<List *> &lists)
 {
-    impl->listsVector = lists;
-    impl->lists = impl->listsVector.data();
+    impl->lists = lists;
 }
diff --git a/src/engine/script_p.h b/src/engine/script_p.h
index a67e4f39..7b643429 100644
--- a/src/engine/script_p.h
+++ b/src/engine/script_p.h
@@ -12,6 +12,7 @@ namespace libscratchcpp
 
 class Target;
 class IEngine;
+class Variable;
 class List;
 
 struct ScriptPrivate
@@ -34,11 +35,10 @@ struct ScriptPrivate
         const Value *constValues = nullptr;
         std::vector<Value> constValuesVector;
 
-        Value **variables = nullptr;
-        std::vector<Value *> variablesVector;
+        std::vector<Value *> variableValues;
+        std::vector<Variable *> variables;
 
-        List **lists = nullptr;
-        std::vector<List *> listsVector;
+        std::vector<List *> lists;
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/virtualmachine.cpp b/src/engine/virtualmachine.cpp
index dc9b3c58..c700c728 100644
--- a/src/engine/virtualmachine.cpp
+++ b/src/engine/virtualmachine.cpp
@@ -50,6 +50,26 @@ void VirtualMachine::setLists(List **lists)
     impl->lists = lists;
 }
 
+/*!
+ * Sets the vector of variables.
+ * Use this instead of setVariables() if you can't store the array (data pointer) anywhere.
+ */
+void VirtualMachine::setVariablesVector(const std::vector<Value *> &variables)
+{
+    impl->variablesVector = variables;
+    impl->variables = impl->variablesVector.data();
+}
+
+/*!
+ * Sets the vector of lists.
+ * Use this instead of setLists() if you can't store the array (data pointer) anywhere.
+ */
+void VirtualMachine::setListsVector(const std::vector<List *> &lists)
+{
+    impl->listsVector = lists;
+    impl->lists = impl->listsVector.data();
+}
+
 /*! Sets the bytecode of the script. */
 void VirtualMachine::setBytecode(unsigned int *code)
 {
diff --git a/src/engine/virtualmachine_p.h b/src/engine/virtualmachine_p.h
index af00076b..262926b7 100644
--- a/src/engine/virtualmachine_p.h
+++ b/src/engine/virtualmachine_p.h
@@ -59,7 +59,9 @@ struct VirtualMachinePrivate
         BlockFunc *functions = nullptr;
         const Value *constValues = nullptr;
         Value **variables = nullptr;
+        std::vector<Value *> variablesVector;
         List **lists = nullptr;
+        std::vector<List *> listsVector;
 
         Value **regs = nullptr;
         size_t regCount = 0;
diff --git a/src/scratch/sprite.cpp b/src/scratch/sprite.cpp
index 206db9c6..b7db560c 100644
--- a/src/scratch/sprite.cpp
+++ b/src/scratch/sprite.cpp
@@ -2,7 +2,9 @@
 
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/ispritehandler.h>
-#include <string>
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 #include <cassert>
 
 #include "sprite_p.h"
@@ -16,6 +18,15 @@ Sprite::Sprite() :
 {
 }
 
+/*! Destroys the Sprite object. */
+Sprite::~Sprite()
+{
+    if (isClone()) {
+        assert(impl->cloneParent);
+        impl->cloneParent->impl->removeClone(this);
+    }
+}
+
 /*! Sets the sprite interface. */
 void Sprite::setInterface(ISpriteHandler *newInterface)
 {
@@ -24,6 +35,100 @@ void Sprite::setInterface(ISpriteHandler *newInterface)
     impl->iface->onSpriteChanged(this);
 }
 
+/*! Creates a clone of the sprite. */
+std::shared_ptr<Sprite> Sprite::clone()
+{
+    IEngine *eng = engine();
+
+    if (eng) {
+        std::shared_ptr<Sprite> clone = std::make_shared<Sprite>();
+
+        if (impl->cloneRoot == nullptr)
+            clone->impl->cloneRoot = this;
+        else
+            clone->impl->cloneRoot = impl->cloneRoot;
+
+        clone->impl->cloneParent = this;
+        impl->childClones.push_back(clone);
+
+        // Copy data
+        clone->setName(name());
+
+        const auto &vars = variables();
+
+        for (auto var : vars)
+            clone->addVariable(std::make_shared<Variable>(var->id(), var->name(), var->value()));
+
+        const auto &l = lists();
+
+        for (auto list : l) {
+            auto newList = std::make_shared<List>(list->id(), list->name());
+            clone->addList(newList);
+
+            for (const Value &item : *list)
+                newList->push_back(item);
+        }
+
+        clone->setCurrentCostume(currentCostume());
+        clone->setLayerOrder(layerOrder());
+        clone->setVolume(volume());
+        clone->setEngine(engine());
+
+        clone->impl->visible = impl->visible;
+        clone->impl->x = impl->x;
+        clone->impl->y = impl->y;
+        clone->impl->size = impl->size;
+        clone->impl->direction = impl->direction;
+        clone->impl->draggable = impl->draggable;
+        clone->impl->rotationStyle = impl->rotationStyle;
+
+        // Call "when I start as clone" scripts
+        eng->initClone(clone.get());
+
+        return clone;
+    }
+
+    return nullptr;
+}
+
+/*! Returns true if this is a clone. */
+bool Sprite::isClone() const
+{
+    return (impl->cloneParent != nullptr);
+}
+
+/*! Returns the sprite this clone was created from, or nullptr if this isn't a clone. */
+Sprite *Sprite::cloneRoot() const
+{
+    return impl->cloneRoot;
+}
+
+/*! Returns the sprite or clone this clone was created from, or nullptr if this isn't a clone. */
+Sprite *Sprite::cloneParent() const
+{
+    return impl->cloneParent;
+}
+
+/*! Returns list of child clones. */
+const std::vector<std::shared_ptr<Sprite>> &Sprite::children() const
+{
+    return impl->childClones;
+}
+
+/*! Returns list of child clones and their children (recursive). */
+std::vector<std::shared_ptr<Sprite>> Sprite::allChildren() const
+{
+    std::vector<std::shared_ptr<Sprite>> ret;
+
+    for (auto clone : impl->childClones) {
+        ret.push_back(clone);
+        auto children = clone->allChildren();
+        ret.insert(ret.end(), children.begin(), children.end());
+    }
+
+    return ret;
+}
+
 /*! Returns true if the sprite is visible. */
 bool Sprite::visible() const
 {
@@ -150,3 +255,8 @@ void Sprite::setRotationStyle(const char *newRotationStyle)
 {
     setRotationStyle(std::string(newRotationStyle));
 }
+
+Target *Sprite::dataSource() const
+{
+    return impl->cloneRoot;
+}
diff --git a/src/scratch/sprite_p.cpp b/src/scratch/sprite_p.cpp
index 81333fbc..22267c42 100644
--- a/src/scratch/sprite_p.cpp
+++ b/src/scratch/sprite_p.cpp
@@ -10,6 +10,19 @@ SpritePrivate::SpritePrivate()
 {
 }
 
+void SpritePrivate::removeClone(Sprite *clone)
+{
+    int index = 0;
+    for (const auto &child : childClones) {
+        if (child.get() == clone) {
+            childClones.erase(childClones.begin() + index);
+            return;
+        }
+
+        index++;
+    }
+}
+
 void SpritePrivate::setCostumeData(const char *data)
 {
     if (iface)
diff --git a/src/scratch/sprite_p.h b/src/scratch/sprite_p.h
index 2656f228..84ca01ea 100644
--- a/src/scratch/sprite_p.h
+++ b/src/scratch/sprite_p.h
@@ -12,9 +12,14 @@ struct SpritePrivate
         SpritePrivate();
         SpritePrivate(const SpritePrivate &) = delete;
 
+        void removeClone(Sprite *clone);
+
         void setCostumeData(const char *data);
 
         ISpriteHandler *iface = nullptr;
+        Sprite *cloneRoot = nullptr;
+        Sprite *cloneParent = nullptr;
+        std::vector<std::shared_ptr<Sprite>> childClones;
         bool visible = true;
         double x = 0;
         double y = 0;
diff --git a/src/scratch/target.cpp b/src/scratch/target.cpp
index e0413a1b..05743f7e 100644
--- a/src/scratch/target.cpp
+++ b/src/scratch/target.cpp
@@ -132,12 +132,18 @@ int Target::findListById(const std::string &id) const
 /*! Returns the list of blocks. */
 const std::vector<std::shared_ptr<Block>> &Target::blocks() const
 {
+    if (Target *source = dataSource())
+        return source->blocks();
+
     return impl->blocks;
 }
 
 /*! Adds a block and returns its index. */
 int Target::addBlock(std::shared_ptr<Block> block)
 {
+    if (Target *source = dataSource())
+        return source->addBlock(block);
+
     auto it = std::find(impl->blocks.begin(), impl->blocks.end(), block);
 
     if (it != impl->blocks.end())
@@ -150,6 +156,9 @@ int Target::addBlock(std::shared_ptr<Block> block)
 /*! Returns the block at index. */
 std::shared_ptr<Block> Target::blockAt(int index) const
 {
+    if (Target *source = dataSource())
+        return source->blockAt(index);
+
     if (index < 0 || index >= impl->blocks.size())
         return nullptr;
 
@@ -159,6 +168,9 @@ std::shared_ptr<Block> Target::blockAt(int index) const
 /*! Returns the index of the block with the given ID. */
 int Target::findBlock(const std::string &id) const
 {
+    if (Target *source = dataSource())
+        return source->findBlock(id);
+
     int i = 0;
     for (auto block : impl->blocks) {
         if (block->id() == id)
@@ -172,7 +184,9 @@ int Target::findBlock(const std::string &id) const
 std::vector<std::shared_ptr<Block>> Target::greenFlagBlocks() const
 {
     std::vector<std::shared_ptr<Block>> ret;
-    for (auto block : impl->blocks) {
+    const auto &blockList = blocks();
+
+    for (auto block : blockList) {
         if (block->opcode() == "event_whenflagclicked")
             ret.push_back(block);
     }
@@ -195,12 +209,18 @@ void Target::setCurrentCostume(int newCostume)
 /*! Returns the list of costumes. */
 const std::vector<std::shared_ptr<Costume>> &Target::costumes() const
 {
+    if (Target *source = dataSource())
+        return source->costumes();
+
     return impl->costumes;
 }
 
 /*! Adds a costume and returns its index. */
 int Target::addCostume(std::shared_ptr<Costume> costume)
 {
+    if (Target *source = dataSource())
+        return source->addCostume(costume);
+
     auto it = std::find(impl->costumes.begin(), impl->costumes.end(), costume);
 
     if (it != impl->costumes.end())
@@ -213,6 +233,9 @@ int Target::addCostume(std::shared_ptr<Costume> costume)
 /*! Returns the costume at index. */
 std::shared_ptr<Costume> Target::costumeAt(int index) const
 {
+    if (Target *source = dataSource())
+        return source->costumeAt(index);
+
     // TODO: Add range check
     return impl->costumes[index];
 }
@@ -220,6 +243,9 @@ std::shared_ptr<Costume> Target::costumeAt(int index) const
 /*! Returns the index of the given costume. */
 int Target::findCostume(const std::string &costumeName) const
 {
+    if (Target *source = dataSource())
+        return source->findCostume(costumeName);
+
     int i = 0;
     for (auto costume : impl->costumes) {
         if (costume->name() == costumeName)
@@ -232,12 +258,18 @@ int Target::findCostume(const std::string &costumeName) const
 /*! Returns the list of sounds. */
 const std::vector<std::shared_ptr<Sound>> &Target::sounds() const
 {
+    if (Target *source = dataSource())
+        return source->sounds();
+
     return impl->sounds;
 }
 
 /*! Adds a sound and returns its index. */
 int Target::addSound(std::shared_ptr<Sound> sound)
 {
+    if (Target *source = dataSource())
+        return source->addSound(sound);
+
     auto it = std::find(impl->sounds.begin(), impl->sounds.end(), sound);
 
     if (it != impl->sounds.end())
@@ -250,6 +282,9 @@ int Target::addSound(std::shared_ptr<Sound> sound)
 /*! Returns the sound at index. */
 std::shared_ptr<Sound> Target::soundAt(int index) const
 {
+    if (Target *source = dataSource())
+        return source->soundAt(index);
+
     // TODO: Add range check
     return impl->sounds[index];
 }
@@ -257,6 +292,9 @@ std::shared_ptr<Sound> Target::soundAt(int index) const
 /*! Returns the index of the sound with the given name. */
 int Target::findSound(const std::string &soundName) const
 {
+    if (Target *source = dataSource())
+        return source->findSound(soundName);
+
     int i = 0;
     for (auto sound : impl->sounds) {
         if (sound->name() == soundName)
@@ -289,3 +327,15 @@ void Target::setVolume(int newVolume)
 {
     impl->volume = newVolume;
 }
+
+/*! Returns the engine. */
+IEngine *Target::engine() const
+{
+    return impl->engine;
+}
+
+/*! Sets the engine. */
+void Target::setEngine(IEngine *engine)
+{
+    impl->engine = engine;
+}
diff --git a/src/scratch/target_p.h b/src/scratch/target_p.h
index 1a990b23..4ea13e05 100644
--- a/src/scratch/target_p.h
+++ b/src/scratch/target_p.h
@@ -11,6 +11,7 @@
 namespace libscratchcpp
 {
 
+class IEngine;
 class Variable;
 class List;
 class Block;
@@ -20,6 +21,7 @@ struct TargetPrivate
         TargetPrivate();
         TargetPrivate(const TargetPrivate &) = delete;
 
+        IEngine *engine = nullptr;
         std::string name;
         std::vector<std::shared_ptr<Variable>> variables;
         std::vector<std::shared_ptr<List>> lists;
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index f9fed87b..f15364c9 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -1,5 +1,7 @@
 #include <scratchcpp/broadcast.h>
 #include <scratchcpp/block.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 
 #include "../common.h"
 #include "testsection.h"
@@ -255,7 +257,11 @@ TEST(EngineTest, Targets)
     auto t1 = std::make_shared<Target>();
     t1->setName("Sprite1");
     auto t2 = std::make_shared<Target>();
+    auto block1 = std::make_shared<Block>("", "");
+    auto block2 = std::make_shared<Block>("", "");
     t2->setName("Sprite2");
+    t2->addBlock(block1);
+    t2->addBlock(block2);
     auto t3 = std::make_shared<Target>();
     t3->setName("Stage");
     engine.setTargets({ t1, t2, t3 });
@@ -271,4 +277,57 @@ TEST(EngineTest, Targets)
     ASSERT_EQ(engine.findTarget("Sprite1"), 0);
     ASSERT_EQ(engine.findTarget("Sprite2"), 1);
     ASSERT_EQ(engine.findTarget("Stage"), 2);
+
+    ASSERT_EQ(t1->engine(), &engine);
+    ASSERT_EQ(t2->engine(), &engine);
+    ASSERT_EQ(t3->engine(), &engine);
+
+    ASSERT_EQ(block1->engine(), &engine);
+    ASSERT_EQ(block2->engine(), &engine);
+}
+
+TEST(EngineTest, VariableOwner)
+{
+    Engine engine;
+    auto t1 = std::make_shared<Target>();
+    auto t2 = std::make_shared<Target>();
+    auto t3 = std::make_shared<Target>();
+
+    auto var1 = std::make_shared<Variable>("", "", Value());
+    auto var2 = std::make_shared<Variable>("", "", Value());
+    auto var3 = std::make_shared<Variable>("", "", Value());
+    auto var4 = std::make_shared<Variable>("", "", Value());
+    t1->addVariable(var1);
+    t1->addVariable(var4);
+    t3->addVariable(var3);
+
+    engine.setTargets({ t1, t2, t3 });
+
+    ASSERT_EQ(engine.variableOwner(var1.get()), t1.get());
+    ASSERT_EQ(engine.variableOwner(var2.get()), nullptr);
+    ASSERT_EQ(engine.variableOwner(var3.get()), t3.get());
+    ASSERT_EQ(engine.variableOwner(var4.get()), t1.get());
+}
+
+TEST(EngineTest, ListOwner)
+{
+    Engine engine;
+    auto t1 = std::make_shared<Target>();
+    auto t2 = std::make_shared<Target>();
+    auto t3 = std::make_shared<Target>();
+
+    auto list1 = std::make_shared<List>("", "");
+    auto list2 = std::make_shared<List>("", "");
+    auto list3 = std::make_shared<List>("", "");
+    auto list4 = std::make_shared<List>("", "");
+    t1->addList(list1);
+    t1->addList(list4);
+    t3->addList(list3);
+
+    engine.setTargets({ t1, t2, t3 });
+
+    ASSERT_EQ(engine.listOwner(list1.get()), t1.get());
+    ASSERT_EQ(engine.listOwner(list2.get()), nullptr);
+    ASSERT_EQ(engine.listOwner(list3.get()), t3.get());
+    ASSERT_EQ(engine.listOwner(list4.get()), t1.get());
 }
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index 7d479689..99c20c4d 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -21,6 +21,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, broadcast, (unsigned int, VirtualMachine *, bool), (override));
         MOCK_METHOD(void, stopScript, (VirtualMachine *), (override));
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));
+        MOCK_METHOD(void, initClone, (Sprite *), (override));
         MOCK_METHOD(void, run, (), (override));
 
         MOCK_METHOD(bool, broadcastRunning, (unsigned int, VirtualMachine *), (override));
@@ -48,11 +49,16 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, std::shared_ptr<Broadcast>), (override));
 
+        MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
+
         MOCK_METHOD(const std::vector<std::shared_ptr<Target>> &, targets, (), (const, override));
         MOCK_METHOD(void, setTargets, (const std::vector<std::shared_ptr<Target>> &), (override));
         MOCK_METHOD(Target *, targetAt, (int), (const, override));
         MOCK_METHOD(int, findTarget, (const std::string &), (const, override));
 
+        MOCK_METHOD(Target *, variableOwner, (Variable *), (const, override));
+        MOCK_METHOD(Target *, listOwner, (List *), (const, override));
+
         MOCK_METHOD(std::vector<std::string> &, extensions, (), (const, override));
         MOCK_METHOD(void, setExtensions, (const std::vector<std::string> &), (override));
 
diff --git a/test/mocks/targetmock.h b/test/mocks/targetmock.h
new file mode 100644
index 00000000..d1ee5459
--- /dev/null
+++ b/test/mocks/targetmock.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <scratchcpp/target.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class TargetMock : public Target
+{
+    public:
+        MOCK_METHOD(Target *, dataSource, (), (const override));
+
+        Target *dataSourceBase() const { return Target::dataSource(); };
+};
diff --git a/test/scratch_classes/CMakeLists.txt b/test/scratch_classes/CMakeLists.txt
index 787496d7..dfdd4c21 100644
--- a/test/scratch_classes/CMakeLists.txt
+++ b/test/scratch_classes/CMakeLists.txt
@@ -35,7 +35,9 @@ add_executable(
 target_link_libraries(
   sprite_test
   GTest::gtest_main
+  GTest::gmock_main
   scratchcpp
+  scratchcpp_mocks
 )
 
 gtest_discover_tests(sprite_test)
@@ -63,7 +65,9 @@ add_executable(
 target_link_libraries(
   target_test
   GTest::gtest_main
+  GTest::gmock_main
   scratchcpp
+  scratchcpp_mocks
 )
 
 gtest_discover_tests(target_test)
diff --git a/test/scratch_classes/sprite_test.cpp b/test/scratch_classes/sprite_test.cpp
index 3c130052..8abe2426 100644
--- a/test/scratch_classes/sprite_test.cpp
+++ b/test/scratch_classes/sprite_test.cpp
@@ -1,9 +1,16 @@
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
+#include <scratchcpp/costume.h>
+#include <enginemock.h>
 
 #include "../common.h"
 
 using namespace libscratchcpp;
 
+using ::testing::_;
+using ::testing::SaveArg;
+
 TEST(SpriteTest, IsStage)
 {
     Sprite sprite;
@@ -18,6 +25,164 @@ TEST(SpriteTest, Visible)
     ASSERT_FALSE(sprite.visible());
 }
 
+TEST(SpriteTest, Clone)
+{
+    Sprite sprite;
+    sprite.setName("Sprite1");
+    auto var1 = std::make_shared<Variable>("a", "var1", "hello");
+    auto var2 = std::make_shared<Variable>("b", "var2", "world");
+    sprite.addVariable(var1);
+    sprite.addVariable(var2);
+    auto c1 = std::make_shared<Costume>("costume1", "", "svg");
+    sprite.addCostume(c1);
+
+    auto list1 = std::make_shared<List>("c", "list1");
+    list1->push_back("item1");
+    list1->push_back("item2");
+    auto list2 = std::make_shared<List>("d", "list2");
+    list2->push_back("test");
+    sprite.addList(list1);
+    sprite.addList(list2);
+
+    sprite.setCurrentCostume(2);
+    sprite.setLayerOrder(5);
+    sprite.setVolume(50);
+
+    sprite.setVisible(false);
+    sprite.setX(100.25);
+    sprite.setY(-45.43);
+    sprite.setSize(54.121);
+    sprite.setDirection(179.4);
+    sprite.setDraggable(true);
+    sprite.setRotationStyle(Sprite::RotationStyle::DoNotRotate);
+
+    auto checkCloneData = [](Sprite *clone) {
+        ASSERT_TRUE(clone);
+        Sprite *root = clone->cloneRoot();
+
+        ASSERT_EQ(clone->name(), "Sprite1");
+        ASSERT_EQ(clone->variables().size(), 2);
+        ASSERT_NE(clone->variables(), root->variables());
+        ASSERT_EQ(clone->variableAt(0)->id(), "a");
+        ASSERT_EQ(clone->variableAt(0)->name(), "var1");
+        ASSERT_EQ(clone->variableAt(0)->value().toString(), "hello");
+        ASSERT_EQ(clone->variableAt(1)->id(), "b");
+        ASSERT_EQ(clone->variableAt(1)->name(), "var2");
+        ASSERT_EQ(clone->variableAt(1)->value().toString(), "world");
+
+        ASSERT_EQ(clone->lists().size(), 2);
+        ASSERT_NE(clone->lists(), root->lists());
+        ASSERT_EQ(clone->listAt(0)->id(), "c");
+        ASSERT_EQ(clone->listAt(0)->name(), "list1");
+        ASSERT_EQ(*clone->listAt(0), std::deque<Value>({ "item1", "item2" }));
+        ASSERT_EQ(clone->listAt(1)->id(), "d");
+        ASSERT_EQ(clone->listAt(1)->name(), "list2");
+        ASSERT_EQ(*clone->listAt(1), std::deque<Value>({ "test" }));
+
+        ASSERT_EQ(clone->currentCostume(), 2);
+        ASSERT_EQ(clone->layerOrder(), 5);
+        ASSERT_EQ(clone->volume(), 50);
+        ASSERT_EQ(clone->engine(), root->engine());
+
+        ASSERT_EQ(clone->visible(), false);
+        ASSERT_EQ(clone->x(), 100.25);
+        ASSERT_EQ(clone->y(), -45.43);
+        ASSERT_EQ(clone->size(), 54.121);
+        ASSERT_EQ(clone->direction(), 179.4);
+        ASSERT_EQ(clone->draggable(), true);
+        ASSERT_EQ(clone->rotationStyle(), Sprite::RotationStyle::DoNotRotate);
+    };
+
+    ASSERT_FALSE(sprite.isClone());
+    ASSERT_EQ(sprite.cloneRoot(), nullptr);
+    ASSERT_EQ(sprite.cloneParent(), nullptr);
+
+    ASSERT_EQ(sprite.clone(), nullptr);
+    ASSERT_FALSE(sprite.isClone());
+    ASSERT_EQ(sprite.cloneRoot(), nullptr);
+    ASSERT_EQ(sprite.cloneParent(), nullptr);
+
+    EngineMock engine;
+    sprite.setEngine(&engine);
+
+    Sprite *clone1;
+    EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone1));
+    ASSERT_EQ(sprite.clone().get(), clone1);
+    ASSERT_FALSE(sprite.isClone());
+    ASSERT_EQ(sprite.cloneRoot(), nullptr);
+    ASSERT_EQ(sprite.cloneParent(), nullptr);
+
+    ASSERT_TRUE(clone1->isClone());
+    ASSERT_EQ(clone1->cloneRoot(), &sprite);
+    ASSERT_EQ(clone1->cloneParent(), &sprite);
+
+    checkCloneData(clone1);
+
+    // Modify root sprite data to make sure parent is used
+    sprite.setLayerOrder(3);
+
+    Sprite *clone2;
+    EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone2));
+    ASSERT_EQ(clone1->clone().get(), clone2);
+    ASSERT_TRUE(clone1->isClone());
+    ASSERT_EQ(clone1->cloneRoot(), &sprite);
+    ASSERT_EQ(clone1->cloneParent(), &sprite);
+    ASSERT_TRUE(clone2->isClone());
+    ASSERT_EQ(clone2->cloneRoot(), &sprite);
+    ASSERT_EQ(clone2->cloneParent(), clone1);
+
+    checkCloneData(clone2);
+
+    Sprite *clone3;
+    EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone3));
+    ASSERT_EQ(clone1->clone().get(), clone3);
+
+    Sprite *clone4;
+    EXPECT_CALL(engine, initClone(_)).WillOnce(SaveArg<0>(&clone4));
+    ASSERT_EQ(sprite.clone().get(), clone4);
+
+    // children
+    const auto &children1 = sprite.children();
+    ASSERT_EQ(children1.size(), 2);
+    ASSERT_EQ(children1[0].get(), clone1);
+    ASSERT_EQ(children1[1].get(), clone4);
+
+    const auto &children2 = clone1->children();
+    ASSERT_EQ(children2.size(), 2);
+    ASSERT_EQ(children2[0].get(), clone2);
+    ASSERT_EQ(children2[1].get(), clone3);
+
+    ASSERT_TRUE(clone2->children().empty());
+
+    ASSERT_TRUE(clone3->children().empty());
+
+    ASSERT_TRUE(clone4->children().empty());
+
+    // allChildren
+    auto allChildren = sprite.allChildren();
+    ASSERT_EQ(allChildren.size(), 4);
+    ASSERT_EQ(allChildren[0].get(), clone1);
+    ASSERT_EQ(allChildren[1].get(), clone2);
+    ASSERT_EQ(allChildren[2].get(), clone3);
+    ASSERT_EQ(allChildren[3].get(), clone4);
+
+    allChildren = clone1->allChildren();
+    ASSERT_EQ(allChildren.size(), 2);
+    ASSERT_EQ(allChildren[0].get(), clone2);
+    ASSERT_EQ(allChildren[1].get(), clone3);
+
+    ASSERT_TRUE(clone2->allChildren().empty());
+
+    ASSERT_TRUE(clone3->allChildren().empty());
+
+    ASSERT_TRUE(clone4->allChildren().empty());
+
+    ASSERT_EQ(clone2->costumes(), sprite.costumes());
+    auto c2 = std::make_shared<Costume>("costume2", "", "png");
+    clone2->addCostume(c2);
+    ASSERT_EQ(clone2->costumes(), sprite.costumes());
+}
+
 TEST(SpriteTest, X)
 {
     Sprite sprite;
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp
index 4112f12d..821a5ff4 100644
--- a/test/scratch_classes/target_test.cpp
+++ b/test/scratch_classes/target_test.cpp
@@ -4,11 +4,15 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/sound.h>
+#include <enginemock.h>
+#include <targetmock.h>
 
 #include "../common.h"
 
 using namespace libscratchcpp;
 
+using ::testing::Return;
+
 TEST(TargetTest, IsStage)
 {
     Target target;
@@ -89,7 +93,9 @@ TEST(TargetTest, Blocks)
     auto b3 = std::make_shared<Block>("c", "motion_ifonedgebounce");
     auto b4 = std::make_shared<Block>("d", "event_whenflagclicked");
 
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, dataSource()).Times(18).WillRepeatedly(Return(nullptr));
+
     ASSERT_EQ(target.addBlock(b1), 0);
     ASSERT_EQ(target.addBlock(b2), 1);
     ASSERT_EQ(target.addBlock(b3), 2);
@@ -111,6 +117,62 @@ TEST(TargetTest, Blocks)
     ASSERT_EQ(target.findBlock("d"), 3);
 
     ASSERT_EQ(target.greenFlagBlocks(), std::vector<std::shared_ptr<Block>>({ b1, b4 }));
+
+    // Test with custom data source
+    Target source;
+
+    EXPECT_CALL(target, dataSource()).WillOnce(Return(&source));
+
+    ASSERT_TRUE(target.blocks().empty());
+
+    TargetMock target2;
+    EXPECT_CALL(target2, dataSource()).Times(18).WillRepeatedly(Return(&source));
+
+    ASSERT_EQ(target2.addBlock(b1), 0);
+    ASSERT_EQ(target2.addBlock(b2), 1);
+    ASSERT_EQ(target2.addBlock(b3), 2);
+    ASSERT_EQ(target2.addBlock(b4), 3);
+    ASSERT_EQ(target2.addBlock(b2), 1); // add existing block
+
+    ASSERT_EQ(target2.blockAt(0), b1);
+    ASSERT_EQ(target2.blockAt(1), b2);
+    ASSERT_EQ(target2.blockAt(2), b3);
+    ASSERT_EQ(target2.blockAt(3), b4);
+    ASSERT_EQ(target2.blockAt(4), nullptr);
+    ASSERT_EQ(target2.blockAt(-1), nullptr);
+
+    ASSERT_EQ(target2.findBlock("e"), -1);
+    ASSERT_EQ(target2.findBlock("a"), 0);
+    ASSERT_EQ(target2.findBlock("b"), 1);
+    ASSERT_EQ(target2.findBlock("c"), 2);
+    ASSERT_EQ(target2.findBlock("d"), 3);
+
+    ASSERT_EQ(target2.greenFlagBlocks(), std::vector<std::shared_ptr<Block>>({ b1, b4 }));
+
+    ASSERT_EQ(target2.blocks(), source.blocks());
+
+    auto b5 = std::make_shared<Block>("e", "data_setvariableto");
+    ASSERT_EQ(source.addBlock(b5), 4);
+
+    EXPECT_CALL(target2, dataSource()).WillOnce(Return(&source));
+    ASSERT_EQ(target2.blocks(), source.blocks());
+
+    ASSERT_EQ(source.blockAt(0), b1);
+    ASSERT_EQ(source.blockAt(1), b2);
+    ASSERT_EQ(source.blockAt(2), b3);
+    ASSERT_EQ(source.blockAt(3), b4);
+    ASSERT_EQ(source.blockAt(4), b5);
+    ASSERT_EQ(source.blockAt(5), nullptr);
+    ASSERT_EQ(source.blockAt(-1), nullptr);
+
+    ASSERT_EQ(source.findBlock("f"), -1);
+    ASSERT_EQ(source.findBlock("a"), 0);
+    ASSERT_EQ(source.findBlock("b"), 1);
+    ASSERT_EQ(source.findBlock("c"), 2);
+    ASSERT_EQ(source.findBlock("d"), 3);
+    ASSERT_EQ(source.findBlock("e"), 4);
+
+    ASSERT_EQ(source.greenFlagBlocks(), std::vector<std::shared_ptr<Block>>({ b1, b4 }));
 }
 
 TEST(TargetTest, CurrentCostume)
@@ -127,7 +189,9 @@ TEST(TargetTest, Costumes)
     auto c2 = std::make_shared<Costume>("costume2", "", "png");
     auto c3 = std::make_shared<Costume>("costume3", "", "svg");
 
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, dataSource()).Times(15).WillRepeatedly(Return(nullptr));
+
     ASSERT_EQ(target.addCostume(c1), 0);
     ASSERT_EQ(target.addCostume(c2), 1);
     ASSERT_EQ(target.addCostume(c3), 2);
@@ -148,6 +212,60 @@ TEST(TargetTest, Costumes)
     ASSERT_EQ(target.findCostume("costume1"), 0);
     ASSERT_EQ(target.findCostume("costume2"), 1);
     ASSERT_EQ(target.findCostume("costume3"), 2);
+
+    // Test with custom data source
+    Target source;
+
+    EXPECT_CALL(target, dataSource()).WillOnce(Return(&source));
+
+    ASSERT_TRUE(target.costumes().empty());
+
+    TargetMock target2;
+    EXPECT_CALL(target2, dataSource()).Times(16).WillRepeatedly(Return(&source));
+
+    ASSERT_EQ(target2.addCostume(c1), 0);
+    ASSERT_EQ(target2.addCostume(c2), 1);
+    ASSERT_EQ(target2.addCostume(c3), 2);
+    ASSERT_EQ(target2.addCostume(c2), 1); // add existing costume
+
+    ASSERT_EQ(target2.costumes().size(), 3);
+    ASSERT_EQ(target2.costumes()[0]->name(), c1->name());
+    ASSERT_EQ(target2.costumes()[1]->name(), c2->name());
+    ASSERT_EQ(target2.costumes()[2]->name(), c3->name());
+
+    ASSERT_EQ(target2.costumeAt(0)->name(), c1->name());
+    ASSERT_EQ(target2.costumeAt(1)->name(), c2->name());
+    ASSERT_EQ(target2.costumeAt(2)->name(), c3->name());
+
+    ASSERT_EQ(target2.findCostume("invalid"), -1);
+    ASSERT_EQ(target2.findCostume("costume1"), 0);
+    ASSERT_EQ(target2.findCostume("costume2"), 1);
+    ASSERT_EQ(target2.findCostume("costume3"), 2);
+
+    ASSERT_EQ(target2.costumes(), source.costumes());
+
+    auto c4 = std::make_shared<Costume>("costume4", "", "png");
+    ASSERT_EQ(source.addCostume(c4), 3);
+
+    EXPECT_CALL(target2, dataSource()).WillOnce(Return(&source));
+    ASSERT_EQ(target2.costumes(), source.costumes());
+
+    ASSERT_EQ(source.costumes().size(), 4);
+    ASSERT_EQ(source.costumes()[0]->name(), c1->name());
+    ASSERT_EQ(source.costumes()[1]->name(), c2->name());
+    ASSERT_EQ(source.costumes()[2]->name(), c3->name());
+    ASSERT_EQ(source.costumes()[3]->name(), c4->name());
+
+    ASSERT_EQ(source.costumeAt(0)->name(), c1->name());
+    ASSERT_EQ(source.costumeAt(1)->name(), c2->name());
+    ASSERT_EQ(source.costumeAt(2)->name(), c3->name());
+    ASSERT_EQ(source.costumeAt(3)->name(), c4->name());
+
+    ASSERT_EQ(source.findCostume("invalid"), -1);
+    ASSERT_EQ(source.findCostume("costume1"), 0);
+    ASSERT_EQ(source.findCostume("costume2"), 1);
+    ASSERT_EQ(source.findCostume("costume3"), 2);
+    ASSERT_EQ(source.findCostume("costume4"), 3);
 }
 
 TEST(TargetTest, Sounds)
@@ -156,7 +274,9 @@ TEST(TargetTest, Sounds)
     auto s2 = std::make_shared<Sound>("sound2", "", "wav");
     auto s3 = std::make_shared<Sound>("sound3", "", "mp3");
 
-    Target target;
+    TargetMock target;
+    EXPECT_CALL(target, dataSource()).Times(15).WillRepeatedly(Return(nullptr));
+
     ASSERT_EQ(target.addSound(s1), 0);
     ASSERT_EQ(target.addSound(s2), 1);
     ASSERT_EQ(target.addSound(s3), 2);
@@ -177,6 +297,60 @@ TEST(TargetTest, Sounds)
     ASSERT_EQ(target.findSound("sound1"), 0);
     ASSERT_EQ(target.findSound("sound2"), 1);
     ASSERT_EQ(target.findSound("sound3"), 2);
+
+    // Test with custom data source
+    Target source;
+
+    EXPECT_CALL(target, dataSource()).WillOnce(Return(&source));
+
+    ASSERT_TRUE(target.sounds().empty());
+
+    TargetMock target2;
+    EXPECT_CALL(target2, dataSource()).Times(16).WillRepeatedly(Return(&source));
+
+    ASSERT_EQ(target2.addSound(s1), 0);
+    ASSERT_EQ(target2.addSound(s2), 1);
+    ASSERT_EQ(target2.addSound(s3), 2);
+    ASSERT_EQ(target2.addSound(s2), 1); // add existing Sound
+
+    ASSERT_EQ(target2.sounds().size(), 3);
+    ASSERT_EQ(target2.sounds()[0]->name(), s1->name());
+    ASSERT_EQ(target2.sounds()[1]->name(), s2->name());
+    ASSERT_EQ(target2.sounds()[2]->name(), s3->name());
+
+    ASSERT_EQ(target2.soundAt(0)->name(), s1->name());
+    ASSERT_EQ(target2.soundAt(1)->name(), s2->name());
+    ASSERT_EQ(target2.soundAt(2)->name(), s3->name());
+
+    ASSERT_EQ(target2.findSound("invalid"), -1);
+    ASSERT_EQ(target2.findSound("sound1"), 0);
+    ASSERT_EQ(target2.findSound("sound2"), 1);
+    ASSERT_EQ(target2.findSound("sound3"), 2);
+
+    ASSERT_EQ(target2.sounds(), source.sounds());
+
+    auto s4 = std::make_shared<Sound>("sound4", "", "wav");
+    ASSERT_EQ(source.addSound(s4), 3);
+
+    EXPECT_CALL(target2, dataSource()).WillOnce(Return(&source));
+    ASSERT_EQ(target2.sounds(), source.sounds());
+
+    ASSERT_EQ(source.sounds().size(), 4);
+    ASSERT_EQ(source.sounds()[0]->name(), s1->name());
+    ASSERT_EQ(source.sounds()[1]->name(), s2->name());
+    ASSERT_EQ(source.sounds()[2]->name(), s3->name());
+    ASSERT_EQ(source.sounds()[3]->name(), s4->name());
+
+    ASSERT_EQ(source.soundAt(0)->name(), s1->name());
+    ASSERT_EQ(source.soundAt(1)->name(), s2->name());
+    ASSERT_EQ(source.soundAt(2)->name(), s3->name());
+    ASSERT_EQ(source.soundAt(3)->name(), s4->name());
+
+    ASSERT_EQ(source.findSound("invalid"), -1);
+    ASSERT_EQ(source.findSound("sound1"), 0);
+    ASSERT_EQ(source.findSound("sound2"), 1);
+    ASSERT_EQ(source.findSound("sound3"), 2);
+    ASSERT_EQ(source.findSound("sound4"), 3);
 }
 
 TEST(TargetTest, LayerOrder)
@@ -194,3 +368,19 @@ TEST(TargetTest, Volume)
     target.setVolume(50);
     ASSERT_EQ(target.volume(), 50);
 }
+
+TEST(TargetTest, Engine)
+{
+    Target target;
+    ASSERT_EQ(target.engine(), nullptr);
+
+    EngineMock engine;
+    target.setEngine(&engine);
+    ASSERT_EQ(target.engine(), &engine);
+}
+
+TEST(TargetTest, DataSource)
+{
+    TargetMock target;
+    ASSERT_EQ(target.dataSourceBase(), nullptr);
+}
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 36ac6cc1..caca86a3 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -1,6 +1,8 @@
 #include <scratchcpp/script.h>
 #include <scratchcpp/virtualmachine.h>
 #include <scratchcpp/target.h>
+#include <scratchcpp/sprite.h>
+#include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <enginemock.h>
 
@@ -8,6 +10,8 @@
 
 using namespace libscratchcpp;
 
+using ::testing::Return;
+
 class ScriptTest : public testing::Test
 {
     public:
@@ -15,6 +19,12 @@ class ScriptTest : public testing::Test
         EngineMock m_engine;
 };
 
+TEST_F(ScriptTest, Constructors)
+{
+    Script script(&m_target, &m_engine);
+    ASSERT_EQ(script.target(), &m_target);
+}
+
 TEST_F(ScriptTest, Bytecode)
 {
     Script script(nullptr, nullptr);
@@ -39,11 +49,13 @@ TEST_F(ScriptTest, Start)
     static std::vector<BlockFunc> functions = { &testFunction };
     static std::vector<Value> constValues = { "test" };
 
-    std::unique_ptr<Value> var = std::make_unique<Value>();
-    static std::vector<Value *> variables = { var.get() };
+    std::unique_ptr<Variable> var1 = std::make_unique<Variable>("a", "", Value());
+    std::unique_ptr<Variable> var2 = std::make_unique<Variable>("b", "", Value());
+    static std::vector<Variable *> variables = { var1.get(), var2.get() };
 
-    std::unique_ptr<List> list = std::make_unique<List>("", "");
-    static std::vector<List *> lists = { list.get() };
+    std::unique_ptr<List> list1 = std::make_unique<List>("c", "");
+    std::unique_ptr<List> list2 = std::make_unique<List>("d", "");
+    static std::vector<List *> lists = { list1.get(), list2.get() };
 
     Script script1(nullptr, nullptr);
 
@@ -79,6 +91,50 @@ TEST_F(ScriptTest, Start)
     ASSERT_EQ(vm->procedures()[0], procedures[0]);
     ASSERT_EQ(vm->functions()[0], functions[0]);
     ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
-    ASSERT_EQ(vm->variables()[0], variables[0]);
+    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
+    ASSERT_EQ(vm->lists()[0], lists[0]);
+
+    Target target;
+    vm = script3.start(&target);
+    ASSERT_TRUE(vm);
+    ASSERT_EQ(vm->target(), &target);
+    ASSERT_EQ(vm->bytecode()[0], bytecode[0]);
+    ASSERT_EQ(vm->procedures()[0], procedures[0]);
+    ASSERT_EQ(vm->functions()[0], functions[0]);
+    ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
+    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
+    ASSERT_EQ(vm->lists()[0], lists[0]);
+
+    Sprite root;
+    root.setEngine(&m_engine);
+    root.addVariable(std::make_shared<Variable>("b", "", Value()));
+    root.addList(std::make_shared<List>("d", ""));
+
+    EXPECT_CALL(m_engine, initClone).Times(1);
+    auto clone = root.clone();
+
+    Script script4(&root, &m_engine);
+    script4.setBytecode(bytecode);
+    script4.setProcedures(procedures);
+    script4.setFunctions(functions);
+    script4.setConstValues(constValues);
+    script4.setVariables(variables);
+    script4.setLists(lists);
+
+    EXPECT_CALL(m_engine, variableOwner(var1.get())).WillOnce(Return(&target));
+    EXPECT_CALL(m_engine, variableOwner(var2.get())).WillOnce(Return(&root));
+    EXPECT_CALL(m_engine, listOwner(list1.get())).WillOnce(Return(&target));
+    EXPECT_CALL(m_engine, listOwner(list2.get())).WillOnce(Return(&root));
+    vm = script4.start(clone.get());
+
+    ASSERT_TRUE(vm);
+    ASSERT_EQ(vm->target(), clone.get());
+    ASSERT_EQ(vm->bytecode()[0], bytecode[0]);
+    ASSERT_EQ(vm->procedures()[0], procedures[0]);
+    ASSERT_EQ(vm->functions()[0], functions[0]);
+    ASSERT_EQ(vm->constValues()[0].toString(), constValues[0].toString());
+    ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
+    ASSERT_EQ(vm->variables()[1], clone->variableAt(clone->findVariableById("b"))->valuePtr());
     ASSERT_EQ(vm->lists()[0], lists[0]);
+    ASSERT_EQ(vm->lists()[1], clone->listAt(clone->findListById("d")).get());
 }
diff --git a/test/virtual_machine/virtual_machine_test.cpp b/test/virtual_machine/virtual_machine_test.cpp
index aa34ec1a..bb692b03 100644
--- a/test/virtual_machine/virtual_machine_test.cpp
+++ b/test/virtual_machine/virtual_machine_test.cpp
@@ -48,24 +48,35 @@ TEST(VirtualMachineTest, ConstValues)
 
 TEST(VirtualMachineTest, Variables)
 {
-    Value var;
-    Value *variables[] = { &var };
+    Value var1, var2;
+    Value *variables[] = { &var1, &var2 };
 
     VirtualMachine vm;
     ASSERT_EQ(vm.variables(), nullptr);
+
     vm.setVariables(variables);
     ASSERT_EQ(vm.variables(), variables);
+
+    vm.setVariablesVector({ &var1, &var2 });
+    ASSERT_EQ(vm.variables()[0], &var1);
+    ASSERT_EQ(vm.variables()[1], &var2);
 }
 
 TEST(VirtualMachineTest, Lists)
 {
-    List list("", "");
-    List *lists[] = { &list };
+    List list1("", "");
+    List list2("", "");
+    List *lists[] = { &list1, &list2 };
 
     VirtualMachine vm;
     ASSERT_EQ(vm.lists(), nullptr);
+
     vm.setLists(lists);
     ASSERT_EQ(vm.lists(), lists);
+
+    vm.setListsVector({ &list1, &list2 });
+    ASSERT_EQ(vm.lists()[0], &list1);
+    ASSERT_EQ(vm.lists()[1], &list2);
 }
 
 TEST(VirtualMachineTest, Bytecode)