diff --git a/engine/includes/components/effectrender.h b/engine/includes/components/effectrender.h
new file mode 100644
index 000000000..87663c095
--- /dev/null
+++ b/engine/includes/components/effectrender.h
@@ -0,0 +1,46 @@
+#ifndef EFFECTRENDER_H
+#define EFFECTRENDER_H
+
+#include "renderable.h"
+
+#include "resources/visualeffect.h"
+
+class ENGINE_EXPORT EffectRender : public Renderable {
+    A_REGISTER(EffectRender, Renderable, Components/Effects)
+
+    A_PROPERTIES(
+        A_PROPERTYEX(VisualEffect *, effect, EffectRender::effect, EffectRender::setEffect, "editor=Asset")
+    )
+    A_NOMETHODS()
+
+public:
+    EffectRender();
+    ~EffectRender() override;
+
+    VisualEffect *effect() const;
+    void setEffect(VisualEffect *effect);
+
+    void deltaUpdate(float dt);
+
+private:
+    AABBox localBound() const override;
+
+    Mesh *meshToDraw() const override;
+
+    void update() override;
+
+    static void effectUpdated(int state, void *ptr);
+
+private:
+    std::vector<float> m_emitterData;
+
+    std::vector<float> m_particleData;
+
+    std::vector<float> m_renderData;
+
+    std::vector<int32_t> m_offsets;
+
+    VisualEffect *m_effect;
+};
+
+#endif // EFFECTRENDER_H
diff --git a/engine/includes/components/particlerender.h b/engine/includes/components/particlerender.h
deleted file mode 100644
index 5f1ea5030..000000000
--- a/engine/includes/components/particlerender.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef PARTICLERENDER_H
-#define PARTICLERENDER_H
-
-#include "renderable.h"
-
-#include "resources/particleeffect.h"
-
-struct GpuQuadParticle {
-    // xyz - world position, w - objectID.x
-    Vector4 worldPosition;
-
-    // xy - size, z - rotation, w - objectID.y
-    Vector4 sizeRot;
-
-    // xy - uvScale, z - distance, w - objectID.z
-    Vector4 uvScaleDist;
-
-    // xy - uvOffset, z - unused, w - objectID.w
-    Vector4 uvOffset;
-
-    // xyzw - color
-    Vector4 color;
-};
-
-class ENGINE_EXPORT ParticleRender : public Renderable {
-    A_REGISTER(ParticleRender, Renderable, Components/Effects)
-
-    A_PROPERTIES(
-        A_PROPERTYEX(ParticleEffect *, effect, ParticleRender::effect, ParticleRender::setEffect, "editor=Asset")
-    )
-    A_NOMETHODS()
-
-public:
-    ParticleRender();
-    ~ParticleRender() override;
-
-    ParticleEffect *effect() const;
-    void setEffect(ParticleEffect *effect);
-
-    void deltaUpdate(float dt);
-
-private:
-    AABBox localBound() const override;
-
-    Mesh *meshToDraw() const override;
-
-    void update() override;
-
-    void loadUserData(const VariantMap &data) override;
-    VariantMap saveUserData() const override;
-
-    static void effectUpdated(int state, void *ptr);
-
-private:
-    std::vector<ParticleTransientData> m_particles;
-
-    std::vector<GpuQuadParticle> m_quads;
-
-    ParticleEffect *m_effect;
-
-    float m_ejectionTime;
-
-    float m_count;
-};
-
-#endif // PARTICLERENDER_H
diff --git a/engine/includes/editor/assetconverter.h b/engine/includes/editor/assetconverter.h
index cfbed2f7b..501462e6b 100644
--- a/engine/includes/editor/assetconverter.h
+++ b/engine/includes/editor/assetconverter.h
@@ -132,9 +132,10 @@ struct Template {
             type(MetaType::INVALID) {
 
     }
-    Template(const QString &p, const uint32_t t) :
-            path(p) {
-        type = MetaType::name(t);
+    Template(const QString &p, const QString &t) :
+            path(p),
+            type(t) {
+
         type = type.replace("*", "");
         type = type.trimmed();
     }
diff --git a/engine/includes/resources/particleeffect.h b/engine/includes/resources/particleeffect.h
deleted file mode 100644
index e52a638b3..000000000
--- a/engine/includes/resources/particleeffect.h
+++ /dev/null
@@ -1,141 +0,0 @@
-#ifndef PARTICLEEFFECT_H
-#define PARTICLEEFFECT_H
-
-#include <resource.h>
-
-#include <material.h>
-#include <mesh.h>
-
-#include <deque>
-#include <anim/variantanimation.h>
-
-class ParticleModificator;
-
-struct ParticleTransientData {
-    Vector4 color;
-
-    Vector4 uv;
-
-    Vector3 velocity;
-
-    float mass;
-
-    Vector3 position;
-
-    float life;
-
-    Vector3 size;
-
-    float lifetime;
-
-    Vector3 rotation;
-
-    float distance;
-
-};
-
-class ENGINE_EXPORT ParticleEffect : public Resource {
-    A_REGISTER(ParticleEffect, Resource, Resources)
-
-    A_PROPERTIES(
-        A_PROPERTY(int, capacity, ParticleEffect::capacity, ParticleEffect::setCapacity),
-        A_PROPERTY(Mesh *, mesh, ParticleEffect::mesh, ParticleEffect::setMesh),
-        A_PROPERTY(Material *, material, ParticleEffect::material, ParticleEffect::setMaterial),
-        A_PROPERTY(float, distibution, ParticleEffect::distribution, ParticleEffect::setDistribution),
-        A_PROPERTY(bool, local, ParticleEffect::local, ParticleEffect::setLocal),
-        A_PROPERTY(bool, continous, ParticleEffect::continous, ParticleEffect::setContinous)
-    )
-
-public:
-    ParticleEffect();
-
-    int capacity() const;
-    void setCapacity(int capacity);
-
-    Mesh *mesh() const;
-    void setMesh(Mesh *mesh);
-
-    Material *material() const;
-    void setMaterial(Material *material);
-
-    float distribution() const;
-    void setDistribution(float distibution);
-
-    bool local() const;
-    void setLocal(bool local);
-
-    bool gpu() const;
-    void setGpu(bool gpu);
-
-    bool continous() const;
-    void setContinous(bool continuous);
-
-    AABBox bound() const;
-
-    const std::vector<ParticleModificator *> &modificators() const;
-
-    void loadUserData(const VariantMap &data) override;
-
-protected:
-    std::vector<ParticleModificator *> m_modificators;
-
-    AABBox m_aabb;
-
-    Mesh *m_mesh;
-
-    Material *m_material;
-
-    float m_distibution;
-
-    int m_capacity;
-
-    bool m_gpu;
-
-    bool m_local;
-
-    bool m_continous;
-
-};
-
-class ENGINE_EXPORT ParticleModificator {
-public:
-    enum Randomness {
-        Off = 0,
-        PerComponent
-    };
-
-    enum Attribute {
-        Lifetime    = 1,
-        Position,
-        Velocity,
-        Rotation,
-        Size,
-        Color,
-
-        ScaleSize,
-        ScaleColor,
-        ScaleRotation
-    };
-
-public:
-    explicit ParticleModificator(ParticleEffect *effect);
-
-    virtual void spawnParticle(ParticleTransientData &data, int index) const;
-    virtual void updateParticle(std::vector<ParticleTransientData> &data, float dt) const;
-
-    void setAttribute(Attribute attribute);
-
-    void loadData(const VariantList &list);
-
-protected:
-    std::vector<Vector4> m_transientData;
-
-    Attribute m_attribute;
-
-    Randomness m_random;
-
-    ParticleEffect *m_effect;
-
-};
-
-#endif // PARTICLEEFFECT_H
diff --git a/engine/includes/resources/visualeffect.h b/engine/includes/resources/visualeffect.h
new file mode 100644
index 000000000..8ed6f9a6f
--- /dev/null
+++ b/engine/includes/resources/visualeffect.h
@@ -0,0 +1,113 @@
+#ifndef VISUALEFFECT_H
+#define VISUALEFFECT_H
+
+#include <resource.h>
+
+#include <material.h>
+#include <mesh.h>
+
+class ENGINE_EXPORT VisualEffect : public Resource {
+    A_REGISTER(VisualEffect, Resource, Resources)
+
+    A_NOPROPERTIES()
+    A_NOMETHODS()
+    A_NOENUMS()
+
+public:
+    struct Argument {
+        int32_t space;
+
+        int32_t size;
+
+        int32_t offset;
+    };
+
+    struct Operator {
+        int32_t op;
+
+        int32_t resultSpace;
+
+        int32_t resultOffset;
+
+        int32_t resultSize;
+
+        std::vector<Argument> arguments;
+
+        std::vector<float> constData;
+    };
+
+    enum EmitterAttributes {
+        EmitterAge = 0,
+        DeltaTime,
+        AliveParticles,
+        SpawnRate,
+        SpawnCounter,
+        LastAttribute
+    };
+
+public:
+    VisualEffect();
+
+    void update(std::vector<float> &emitter, std::vector<float> &particles, std::vector<float> &render);
+
+    int capacity() const;
+    void setCapacity(int capacity);
+
+    Mesh *mesh() const;
+    void setMesh(Mesh *mesh);
+
+    Material *material() const;
+    void setMaterial(Material *material);
+
+    float spawnRate() const;
+    void setSpawnRate(float rate);
+
+    bool local() const;
+    void setLocal(bool local);
+
+    bool gpu() const;
+    void setGpu(bool gpu);
+
+    bool continous() const;
+    void setContinous(bool continuous);
+
+    int particleStride() const;
+    int renderableStride() const;
+
+    AABBox bound() const;
+
+    void loadUserData(const VariantMap &data) override;
+
+protected:
+    std::vector<Operator> m_spawnOperations;
+    std::vector<Operator> m_updateOperations;
+    std::vector<Operator> m_renderOperations;
+
+    AABBox m_aabb;
+
+    Mesh *m_mesh;
+
+    Material *m_material;
+
+    float m_spawnRate;
+
+    int m_capacity;
+
+    int m_particleStride;
+
+    int m_renderableStride;
+
+    bool m_gpu;
+
+    bool m_local;
+
+    bool m_continous;
+
+private:
+    void apply(std::vector<Operator> &operations, std::vector<float> &emitter, std::vector<float> &particle, std::vector<float> &render, int stage) const;
+
+    void loadOperations(const VariantList &list, std::vector<Operator> &operations);
+
+};
+
+#endif // VISUALEFFECT_H
diff --git a/engine/src/components/effectrender.cpp b/engine/src/components/effectrender.cpp
new file mode 100644
index 000000000..04a7283b9
--- /dev/null
+++ b/engine/src/components/effectrender.cpp
@@ -0,0 +1,168 @@
+#include "effectrender.h"
+
+#include <algorithm>
+#include <cstring>
+#include <cfloat>
+
+#include "actor.h"
+#include "transform.h"
+#include "camera.h"
+
+#include "visualeffect.h"
+#include "material.h"
+
+#include "commandbuffer.h"
+#include "timer.h"
+
+/*!
+    \class EffectRender
+    \brief Draws a particle effect on the scene.
+    \inmodule Components
+
+    The ParticleRender component allows you to display Particle Effects such as fire and explosions.
+*/
+
+EffectRender::EffectRender() :
+        m_effect(nullptr) {
+
+}
+
+EffectRender::~EffectRender() {
+    if(m_effect) {
+        m_effect->unsubscribe(this);
+    }
+}
+/*!
+    \internal
+*/
+void EffectRender::update() {
+    deltaUpdate(Timer::deltaTime() * Timer::scale());
+}
+/*!
+    \internal
+*/
+void EffectRender::deltaUpdate(float dt) {
+    if(m_effect && isEnabled()) {
+        Camera *camera = Camera::current();
+        if(camera == nullptr || m_materials.empty()) {
+            return;
+        }
+
+        float &emitterAge = m_emitterData[VisualEffect::EmitterAge];
+        float &deltaTime = m_emitterData[VisualEffect::DeltaTime];
+
+        deltaTime = dt;
+
+        if(m_effect->continous() || emitterAge > 0.0f) {
+            float &emitterSpawnCounter = m_emitterData[VisualEffect::SpawnCounter];
+
+            emitterSpawnCounter += m_effect->spawnRate() * deltaTime;
+
+            if(emitterAge > 0.0f) {
+                emitterAge -= dt;
+            }
+        }
+
+        m_effect->update(m_emitterData, m_particleData, m_renderData);
+
+        if(m_effect->local()) {
+            Matrix4 world(transform()->worldTransform());
+
+            int32_t count = static_cast<int32_t>(m_emitterData[VisualEffect::AliveParticles]);
+            int32_t stride = m_effect->renderableStride();
+
+            for(int32_t i = 0; i < count; i++) {
+                int index = i * stride;
+                Vector3 p(world * Vector3(m_renderData[index + 12], m_renderData[index + 13], m_renderData[index + 14]));
+                m_renderData[index + 12] = p.x;
+                m_renderData[index + 13] = p.y;
+                m_renderData[index + 14] = p.z;
+            }
+        }
+
+        MaterialInstance *instance = m_materials.front();
+        instance->setInstanceCount(static_cast<int32_t>(m_emitterData[VisualEffect::AliveParticles]));
+
+        memcpy(instance->rawUniformBuffer().data(), m_renderData.data(), m_renderData.size());
+    }
+}
+/*!
+    \internal
+*/
+Mesh *EffectRender::meshToDraw() const {
+    return m_effect ? m_effect->mesh() : nullptr;
+}
+/*!
+    Returns a ParticleEffect assigned to the this component.
+*/
+VisualEffect *EffectRender::effect() const {
+    return m_effect;
+}
+/*!
+    Assgines a particle \a effect to the this component.
+*/
+void EffectRender::setEffect(VisualEffect *effect) {
+    PROFILE_FUNCTION();
+
+    if(m_effect) {
+        m_effect->unsubscribe(this);
+    }
+
+    m_effect = effect;
+    if(m_effect) {
+        effectUpdated(Resource::Ready, this);
+        m_effect->subscribe(&EffectRender::effectUpdated, this);
+    }
+}
+/*!
+    \internal
+*/
+AABBox EffectRender::localBound() const {
+    if(m_effect) {
+        m_effect->bound();
+    }
+    return Renderable::localBound();
+}
+/*!
+    \internal
+*/
+void EffectRender::effectUpdated(int state, void *ptr) {
+    if(state == Resource::Ready) {
+        EffectRender *p = static_cast<EffectRender *>(ptr);
+
+        // Update materials
+        for(auto it : p->m_materials) {
+            delete it;
+        }
+        p->m_materials.clear();
+
+        int capacity = p->m_effect->capacity();
+
+        if(p->m_effect->material()) {
+            MaterialInstance *instance = p->m_effect->material()->createInstance(Material::Billboard);
+
+            instance->setInstanceCount(capacity);
+
+            p->m_materials.push_back(instance);
+        }
+
+        // Update emitter buffer
+        p->m_emitterData.resize(VisualEffect::LastAttribute);
+        // Update particles buffer
+        p->m_particleData.resize(capacity * p->m_effect->particleStride());
+
+        int renderableStride = p->m_effect->renderableStride();
+        p->m_renderData.resize(capacity * renderableStride);
+
+        Vector4 colorID(CommandBuffer::idToColor(p->actor()->uuid()));
+
+        for(int i = 0; i < capacity; i++) {
+            int r = i * renderableStride;
+
+            p->m_renderData[r + 3] = colorID.x;
+            p->m_renderData[r + 7] = colorID.y;
+            p->m_renderData[r + 11] = colorID.z;
+            p->m_renderData[r + 15] = colorID.w;
+        }
+    }
+}
diff --git a/engine/src/components/particlerender.cpp b/engine/src/components/particlerender.cpp
deleted file mode 100644
index 9db9c51d8..000000000
--- a/engine/src/components/particlerender.cpp
+++ /dev/null
@@ -1,237 +0,0 @@
-#include "particlerender.h"
-
-#include <algorithm>
-#include <cstring>
-#include <cfloat>
-
-#include "actor.h"
-#include "transform.h"
-#include "camera.h"
-
-#include "particleeffect.h"
-#include "material.h"
-
-#include "commandbuffer.h"
-#include "timer.h"
-
-namespace {
-    const char *gEffect("Effect");
-};
-
-/*!
-    \class ParticleRender
-    \brief Draws a particle effect on the scene.
-    \inmodule Components
-
-    The ParticleRender component allows you to display Particle Effects such as fire and explosions.
-*/
-
-ParticleRender::ParticleRender() :
-        m_ejectionTime(0.0f),
-        m_count(0.0f),
-        m_effect(nullptr) {
-
-}
-
-ParticleRender::~ParticleRender() {
-    if(m_effect) {
-        m_effect->unsubscribe(this);
-    }
-}
-/*!
-    \internal
-*/
-void ParticleRender::update() {
-    deltaUpdate(Timer::deltaTime() * Timer::scale());
-}
-/*!
-    \internal
-*/
-void ParticleRender::deltaUpdate(float dt) {
-    if(m_effect && isEnabled()) {
-        Camera *camera = Camera::current();
-        if(camera == nullptr || m_materials.empty()) {
-            return;
-        }
-
-        bool local = m_effect->local();
-        bool continous = m_effect->continous();
-
-        if(continous || m_ejectionTime > 0.0f) {
-            m_count += m_effect->distribution() * dt;
-
-            for(int i = 0; i < m_particles.size(); i++) {
-                if(m_count >= 1.0f) {
-                    ParticleTransientData &p = m_particles[i];
-                    if(p.life <= 0.0f) {
-                        p.position = Vector3();
-                        p.size = Vector3(1.0f);
-                        p.color = Vector4(1.0f);
-                        p.uv = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
-
-                        for(auto &it : m_effect->modificators()) {
-                            it->spawnParticle(p, i);
-                        }
-
-                        p.life = p.lifetime;
-
-                        m_count -= 1.0f;
-                    }
-                } else {
-                    break;
-                }
-            }
-
-            if(!continous) {
-                m_ejectionTime -= dt;
-            }
-        }
-
-        // Update particles
-        for(auto &it : m_effect->modificators()) {
-            it->updateParticle(m_particles, dt);
-        }
-
-        Matrix4 world(transform()->worldTransform());
-        Vector3 cameraPos(camera->transform()->worldPosition());
-
-        uint32_t visibleCount = 0;
-        for(int i = 0; i < m_particles.size(); i++) {
-            ParticleTransientData &p = m_particles[i];
-            p.life -= dt;
-
-            if(p.life > 0.0f) {
-                GpuQuadParticle &q = m_quads[visibleCount];
-
-                q.worldPosition = (local) ? world * p.position : p.position;
-
-                q.sizeRot.x = p.size.x;
-                q.sizeRot.y = p.size.y;
-                q.sizeRot.z = p.rotation.z;
-
-                q.uvScaleDist.x = p.uv.x;
-                q.uvScaleDist.y = p.uv.y;
-                q.uvScaleDist.z = (cameraPos - q.worldPosition).sqrLength();
-
-                q.uvOffset.x = p.uv.z;
-                q.uvOffset.y = p.uv.w;
-
-                q.color = p.color;
-
-                visibleCount++;
-            }
-        }
-
-        std::sort(m_quads.begin(), m_quads.end(), [](const GpuQuadParticle &left, const GpuQuadParticle &right) { return left.uvScaleDist.z > right.uvScaleDist.z; });
-
-        MaterialInstance *instance = m_materials.front();
-        instance->setInstanceCount(visibleCount);
-
-        memcpy(instance->rawUniformBuffer().data(), m_quads.data(), sizeof(GpuQuadParticle) * m_quads.size());
-    }
-}
-/*!
-    \internal
-*/
-Mesh *ParticleRender::meshToDraw() const {
-    return m_effect ? m_effect->mesh() : nullptr;
-}
-/*!
-    Returns a ParticleEffect assigned to the this component.
-*/
-ParticleEffect *ParticleRender::effect() const {
-    return m_effect;
-}
-/*!
-    Assgines a particle \a effect to the this component.
-*/
-void ParticleRender::setEffect(ParticleEffect *effect) {
-    PROFILE_FUNCTION();
-
-    if(m_effect != effect) {
-        if(m_effect) {
-            m_effect->unsubscribe(this);
-        }
-
-        m_effect = effect;
-        if(m_effect) {
-            effectUpdated(Resource::Ready, this);
-            m_effect->subscribe(&ParticleRender::effectUpdated, this);
-        }
-    }
-}
-/*!
-    \internal
-*/
-AABBox ParticleRender::localBound() const {
-    if(m_effect) {
-        m_effect->bound();
-    }
-    return Renderable::localBound();
-}
-/*!
-    \internal
-*/
-void ParticleRender::loadUserData(const VariantMap &data) {
-    PROFILE_FUNCTION();
-
-    Component::loadUserData(data);
-
-    auto it = data.find(gEffect);
-    if(it != data.end()) {
-        setEffect(Engine::loadResource<ParticleEffect>((*it).second.toString()));
-    }
-}
-/*!
-    \internal
-*/
-VariantMap ParticleRender::saveUserData() const {
-    PROFILE_FUNCTION();
-
-    VariantMap result = Component::saveUserData();
-
-    std::string ref = Engine::reference(m_effect);
-    if(!ref.empty()) {
-        result[gEffect] = ref;
-    }
-
-    return result;
-}
-/*!
-    \internal
-*/
-void ParticleRender::effectUpdated(int state, void *ptr) {
-    if(state == Resource::Ready) {
-        ParticleRender *p = static_cast<ParticleRender *>(ptr);
-
-        // Update materials
-        for(auto it : p->m_materials) {
-            delete it;
-        }
-        p->m_materials.clear();
-
-        int capacity = p->m_effect->capacity();
-
-        if(p->m_effect->material()) {
-            MaterialInstance *instance = p->m_effect->material()->createInstance(Material::Billboard);
-
-            instance->setInstanceCount(capacity);
-
-            p->m_materials.push_back(instance);
-        }
-
-        // Update particles pool
-        p->m_particles.resize(capacity);
-
-        p->m_quads.resize(capacity);
-
-        Vector4 colorID(CommandBuffer::idToColor(p->actor()->uuid()));
-
-        for(int i = 0; i < capacity; i++) {
-            p->m_quads[i].worldPosition.w = colorID.x;
-            p->m_quads[i].sizeRot.w       = colorID.y;
-            p->m_quads[i].uvScaleDist.w   = colorID.z;
-            p->m_quads[i].uvOffset.w      = colorID.w;
-        }
-    }
-}
diff --git a/engine/src/editor/projectsettings.cpp b/engine/src/editor/projectsettings.cpp
index d0ea7d71b..c7b4338ab 100644
--- a/engine/src/editor/projectsettings.cpp
+++ b/engine/src/editor/projectsettings.cpp
@@ -15,6 +15,7 @@
 
 #include "config.h"
 
+#include <components/actor.h>
 #include <resources/map.h>
 
 #include <editor/pluginmanager.h>
@@ -131,7 +132,7 @@ void ProjectSettings::loadSettings() {
                 if(index > -1) {
                     QMetaProperty property = meta->property(index);
                     if(property.userType() == qMetaTypeId<Template>()) {
-                        value = QVariant::fromValue<Template>(Template(value.toString(), MetaType::type<Actor *>()));
+                        value = QVariant::fromValue(Template(value.toString(), MetaType::name<Actor>()));
                     }
                     property.write(this, value);
                 } else {
@@ -287,7 +288,7 @@ void ProjectSettings::setProjectVersion(const QString &value) {
 }
 
 Template ProjectSettings::firstMap() const {
-    return Template(m_firstMap, MetaType::type<Map *>());
+    return Template(m_firstMap, MetaType::name<Map>());
 }
 void ProjectSettings::setFirstMap(const Template &value) {
     if(m_firstMap != value.path) {
diff --git a/engine/src/resources/particleeffect.cpp b/engine/src/resources/particleeffect.cpp
deleted file mode 100644
index af090ad91..000000000
--- a/engine/src/resources/particleeffect.cpp
+++ /dev/null
@@ -1,302 +0,0 @@
-#include "particleeffect.h"
-
-#include "material.h"
-#include "mesh.h"
-
-namespace {
-    const char *gEmitters("Emitters");
-}
-
-/*!
-    \class ParticleModificator
-    \brief The ParticleModificator class represents a base class for particle system modifiers, allowing customization of particle behavior during its lifecycle.
-    \inmodule Resources
-
-    The ParticleModificator class serves as a base class for particle system modifiers, providing virtual methods for modifying particle data during spawn and update operations.
-    The class also includes methods for loading modification data from a variant list.
-    Users can extend this class to create custom particle modifiers by overriding the virtual methods and providing specific modification behavior.
-*/
-
-ParticleModificator::ParticleModificator(ParticleEffect *effect) :
-        m_attribute(Attribute::Lifetime),
-        m_random(Randomness::Off),
-        m_effect(effect) {
-}
-/*!
-    Modifies a \a particle attribute when spawn a new particle.
-*/
-void ParticleModificator::spawnParticle(ParticleTransientData &data, int index) const {
-    A_UNUSED(data);
-}
-/*!
-    Virtual method for modifying particle \a data during each frame update.
-    Parameter \a dt used to pass delta time from Timer.
-*/
-void ParticleModificator::updateParticle(std::vector<ParticleTransientData> &data, float dt) const {
-    A_UNUSED(data);
-    A_UNUSED(dt);
-}
-
-/*!
-    Sets and \a attribute to modify.
-*/
-void ParticleModificator::setAttribute(Attribute attribute) {
-    m_attribute = attribute;
-}
-/*!
-    Loads serialized modification data from a variant \a list.
-*/
-void ParticleModificator::loadData(const VariantList &list) {
-    auto it = list.begin();
-    m_random = static_cast<Randomness>((*it).toInt());
-    it++;
-
-    Vector4 min((*it).toVector4());
-    it++;
-
-    if(m_random == Randomness::PerComponent) {
-        Vector4 max((*it).toVector4());
-
-        m_transientData.resize(m_effect->capacity());
-
-        for(auto &it : m_transientData) {
-            it = Vector4(RANGE(min.x, max.x), RANGE(min.y, max.y), RANGE(min.z, max.z), RANGE(min.w, max.w));
-        }
-    } else {
-        m_transientData.push_back(min);
-    }
-}
-
-class SetAttribute: public ParticleModificator {
-public:
-    explicit SetAttribute(ParticleEffect *effect) :
-        ParticleModificator(effect) {
-
-    }
-
-    void spawnParticle(ParticleTransientData &data, int index) const override {
-        if(data.life <= 0.0f) {
-            const Vector4 &v = m_transientData[(m_random == Off) ? 0 : index];
-
-            switch(m_attribute) {
-                case Lifetime: data.lifetime = v.x; break;
-                case Position: data.position = v; break;
-                case Rotation: data.rotation.z = v.x * DEG2RAD; break;
-                case Color: data.color = v; break;
-                case Size: data.size = v; break;
-                default: break;
-            }
-        }
-    }
-};
-
-class UpdateAttribute: public ParticleModificator {
-public:
-    explicit UpdateAttribute(ParticleEffect *effect) :
-        ParticleModificator(effect) {
-
-    }
-
-    void spawnParticle(ParticleTransientData &data, int index) const override {
-        if(m_attribute == Velocity) {
-            data.velocity = m_transientData[(m_random == Off) ? 0 : index];
-        }
-    }
-
-    void updateParticle(std::vector<ParticleTransientData> &data, float dt) const override {
-        for(int i = 0; i < data.size(); i++) {
-            const Vector4 &v = m_transientData[(m_random == Off) ? 0 : i];
-
-            switch(m_attribute) {
-                case Velocity: data[i].position += data[i].velocity * dt; break;
-                case ScaleColor: data[i].color += v * dt; break;
-                case ScaleSize: data[i].size += v * dt; break;
-                case ScaleRotation: data[i].rotation += v * dt; break;
-                default: break;
-            }
-        }
-    }
-};
-/*!
-    \class ParticleEffect
-    \brief Contains all necessary information about the effect.
-    \inmodule Resources
-
-    PartcileEffect alows developer to create or modify a complex particle effects.
-*/
-
-ParticleEffect::ParticleEffect() :
-        m_mesh(nullptr),
-        m_material(nullptr),
-        m_distibution(1.0f),
-        m_capacity(1),
-        m_gpu(false),
-        m_local(false),
-        m_continous(true) {
-
-}
-
-/*!
-    Returns a mesh associated with the particle emitter.
-*/
-Mesh *ParticleEffect::mesh() const {
-    return m_mesh;
-}
-/*!
-    Sets a \a mesh associated with the particle emitter.
-*/
-void ParticleEffect::setMesh(Mesh *mesh) {
-    m_mesh = mesh;
-}
-/*!
-    Returns a material associated with the particle emitter.
-*/
-Material *ParticleEffect::material() const {
-    return m_material;
-}
-/*!
-    Sets a \a material associated with the particle emitter.
-*/
-void ParticleEffect::setMaterial(Material *material) {
-    m_material = material;
-}
-/*!
-    Returns a distribution factor of emitted particles.
-*/
-float ParticleEffect::distribution() const {
-    return m_distibution;
-}
-/*!
-    Sets a \a distribution factor of emitted particles.
-*/
-void ParticleEffect::setDistribution(float distribution) {
-    m_distibution = distribution;
-}
-/*!
-    Returns a maximum number of particles to emit.
-*/
-int ParticleEffect::capacity() const {
-    return m_capacity;
-}
-/*!
-    Sets a maximum \a capacity of particles to emit.
-*/
-void ParticleEffect::setCapacity(int capacity) {
-    m_capacity = capacity;
-}
-/*!
-    Returns true if particles are in local space, false otherwise.
-*/
-bool ParticleEffect::local() const {
-    return m_local;
-}
-/*!
-    Setter for the \a local flag indicating local particle space.
-*/
-void ParticleEffect::setLocal(bool local) {
-    m_local = local;
-}
-/*!
-    Returns true if GPU particle simulation is enabled, false otherwise.
-
-    \note Gpu simulation is not supported yet.
-*/
-bool ParticleEffect::gpu() const {
-    return m_gpu;
-}
-/*!
-    Setter for the \a gpu flag indicating GPU particle simulation.
-
-    \note Gpu simulation is not supported yet.
-*/
-void ParticleEffect::setGpu(bool gpu) {
-    m_gpu = gpu;
-}
-/*!
-    Returns true for continuous emission, false for one time emission.
-*/
-bool ParticleEffect::continous() const {
-    return m_continous;
-}
-/*!
-    Setter for the \a continuous flag indicating continuous particle emission.
-*/
-void ParticleEffect::setContinous(bool continuous) {
-    m_continous = continuous;
-}
-/*!
-    Returns bounding box for the emitter.
-*/
-AABBox ParticleEffect::bound() const {
-    return m_aabb;
-}
-/*!
-    Returns an array of particle modifiers.
-*/
-const std::vector<ParticleModificator *> &ParticleEffect::modificators() const {
-    return m_modificators;
-}
-/*!
-    \internal
-*/
-void ParticleEffect::loadUserData(const VariantMap &data) {
-    PROFILE_FUNCTION();
-
-    for(auto it : m_modificators) {
-        delete it;
-    }
-    m_modificators.clear();
-
-    auto section = data.find(gEmitters);
-    if(section != data.end()) {
-        VariantList list = (*section).second.value<VariantList>();
-        for(auto &e : list) {
-            VariantList fields = e.value<VariantList>();
-            auto it = fields.begin();
-
-            setMesh(Engine::loadResource<Mesh>((*it).toString()));
-            it++;
-            setMaterial(Engine::loadResource<Material>((*it).toString()));
-            it++;
-            setGpu((*it).toBool());
-            it++;
-            setLocal((*it).toBool());
-            it++;
-            setContinous((*it).toBool());
-            it++;
-            setCapacity((*it).toInt());
-            it++;
-            setDistribution((*it).toFloat());
-            it++;
-
-            // Particle spawn attribute modificators
-            for(auto &m : (*it).value<VariantList>()) {
-                VariantList mods = m.value<VariantList>();
-                auto mod = mods.begin();
-                ParticleModificator::Attribute type = static_cast<ParticleModificator::Attribute>((*mod).toInt());
-
-                ParticleModificator *modificator = nullptr;
-                switch (type) {
-                    case ParticleModificator::Lifetime:
-                    case ParticleModificator::Size:
-                    case ParticleModificator::Color:
-                    case ParticleModificator::Rotation:
-                    case ParticleModificator::Position: modificator = new SetAttribute(this); break;
-
-                    case ParticleModificator::ScaleSize:
-                    case ParticleModificator::ScaleColor:
-                    case ParticleModificator::ScaleRotation:
-                    case ParticleModificator::Velocity: modificator = new UpdateAttribute(this); break;
-                    default: break;
-                }
-
-                if(modificator) {
-                    mod++;
-                    modificator->setAttribute(type);
-                    modificator->loadData((*mod).value<VariantList>());
-                    m_modificators.push_back(modificator);
-                }
-            }
-        }
-    }
-}
diff --git a/engine/src/resources/visualeffect.cpp b/engine/src/resources/visualeffect.cpp
new file mode 100644
index 000000000..82ed71c0e
--- /dev/null
+++ b/engine/src/resources/visualeffect.cpp
@@ -0,0 +1,363 @@
+#include "visualeffect.h"
+
+#include "material.h"
+#include "mesh.h"
+
+#include <array>
+
+namespace {
+    const char *gEmitters("Emitters");
+}
+
+enum Stages {
+    State,
+    Spawn,
+    Update,
+    Render
+};
+
+enum Operation {
+    Mov = 0,
+    Add,
+    Sub,
+    Mul,
+    Div
+};
+
+enum Space {
+    System,
+    Emitter,
+    Particle,
+    Renderable,
+    Local,
+    Constant,
+    Random
+};
+
+/*!
+    \class VisualEffect
+    \brief Contains all necessary information about the effect.
+    \inmodule Resources
+
+    VisualEffect alows developer to create a complex visual effects.
+*/
+
+VisualEffect::VisualEffect() :
+        m_mesh(nullptr),
+        m_material(nullptr),
+        m_spawnRate(1.0f),
+        m_capacity(1),
+        m_particleStride(1), // Store an age at least
+        m_renderableStride(20), // Matrix4 + Color
+        m_gpu(false),
+        m_local(false),
+        m_continous(true) {
+
+}
+
+void VisualEffect::update(std::vector<float> &emitter, std::vector<float> &particles, std::vector<float> &render) {
+    if(!m_spawnOperations.empty()) {
+        apply(m_spawnOperations, emitter, particles, render, Spawn);
+    }
+
+    if(!m_updateOperations.empty()) {
+        apply(m_updateOperations, emitter, particles, render, Update);
+    }
+
+    if(!m_renderOperations.empty()) {
+        apply(m_renderOperations, emitter, particles, render, Render);
+    }
+}
+/*!
+    Returns a mesh associated with the particle emitter.
+*/
+Mesh *VisualEffect::mesh() const {
+    return m_mesh;
+}
+/*!
+    Sets a \a mesh associated with the particle emitter.
+*/
+void VisualEffect::setMesh(Mesh *mesh) {
+    m_mesh = mesh;
+}
+/*!
+    Returns a material associated with the particle emitter.
+*/
+Material *VisualEffect::material() const {
+    return m_material;
+}
+/*!
+    Sets a \a material associated with the particle emitter.
+*/
+void VisualEffect::setMaterial(Material *material) {
+    m_material = material;
+}
+/*!
+    Returns a distribution factor of emitted particles.
+*/
+float VisualEffect::spawnRate() const {
+    return m_spawnRate;
+}
+/*!
+    Sets spawn \a rate factor of emitted particles.
+*/
+void VisualEffect::setSpawnRate(float rate) {
+    m_spawnRate = rate;
+}
+/*!
+    Returns a maximum number of particles to emit.
+*/
+int VisualEffect::capacity() const {
+    return m_capacity;
+}
+/*!
+    Return a size for particle atribute structure.
+*/
+int VisualEffect::particleStride() const {
+    return m_particleStride;
+}
+/*!
+    Return a size for particle atribute structure.
+*/
+int VisualEffect::renderableStride() const {
+    return m_renderableStride;
+}
+/*!
+    Sets a maximum \a capacity of particles to emit.
+*/
+void VisualEffect::setCapacity(int capacity) {
+    m_capacity = capacity;
+}
+/*!
+    Returns true if particles are in local space, false otherwise.
+*/
+bool VisualEffect::local() const {
+    return m_local;
+}
+/*!
+    Setter for the \a local flag indicating local particle space.
+*/
+void VisualEffect::setLocal(bool local) {
+    m_local = local;
+}
+/*!
+    Returns true if GPU particle simulation is enabled, false otherwise.
+
+    \note Gpu simulation is not supported yet.
+*/
+bool VisualEffect::gpu() const {
+    return m_gpu;
+}
+/*!
+    Setter for the \a gpu flag indicating GPU particle simulation.
+
+    \note Gpu simulation is not supported yet.
+*/
+void VisualEffect::setGpu(bool gpu) {
+    m_gpu = gpu;
+}
+/*!
+    Returns true for continuous emission, false for one time emission.
+*/
+bool VisualEffect::continous() const {
+    return m_continous;
+}
+/*!
+    Setter for the \a continuous flag indicating continuous particle emission.
+*/
+void VisualEffect::setContinous(bool continuous) {
+    m_continous = continuous;
+}
+/*!
+    Returns bounding box for the emitter.
+*/
+AABBox VisualEffect::bound() const {
+    return m_aabb;
+}
+/*!
+    Modifies a \a particle attributes stored in data buffer.
+    The \a emitter buffer contains actual emitter state.
+    The \a render buffer contains actual renderables data.
+*/
+void VisualEffect::apply(std::vector<Operator> &operations, std::vector<float> &emitter, std::vector<float> &particle, std::vector<float> &render, int stage) const {
+    Vector4 local;
+
+    bool spawn = stage == Spawn;
+
+    emitter[AliveParticles] = 0;
+    for(int i = 0; i < m_capacity; i++) {
+        float *p = &particle[i * m_particleStride];
+        float *r = &render[static_cast<int32_t>(emitter[AliveParticles]) * m_renderableStride];
+
+        if((*p > 0) != spawn) { // check alive (for spawn case)
+            emitter[AliveParticles]++;
+
+            if(spawn) {
+                if(emitter[SpawnCounter] < 1.0f) {
+                    break;
+                }
+                emitter[SpawnCounter] -= 1.0f;
+            }
+
+            for(auto &it : operations) {
+                float *ret = nullptr;
+                switch(it.resultSpace) {
+                    case Space::Emitter: ret = &emitter[it.resultOffset]; break;
+                    case Space::Particle: ret = &p[it.resultOffset]; break;
+                    case Space::Renderable: ret = &r[it.resultOffset]; break;
+                    case Space::Local: ret = local.v; break;
+                    default: break;
+                }
+
+                std::array<const float *, 2> arg = {ret, ret};
+                std::array<bool, 2> sgl = {false, false};
+
+                for(int b = 0; b < 2; b++) {
+                    Argument &argument = it.arguments[b];
+
+                    if(argument.size == 1) {
+                        sgl[b] = true;
+                    }
+
+                    switch(argument.space) {
+                        case Space::Emitter: arg[b] = &emitter[argument.offset]; break;
+                        case Space::Particle: arg[b] = &p[argument.offset]; break;
+                        case Space::Local: arg[b] = local.v; break;
+                        case Space::Constant: arg[b] = it.constData.data(); break;
+                        case Space::Random: arg[b] = &it.constData[i * it.resultSize]; break;
+                        default: break;
+                    }
+                }
+
+                for(int c = 0; c < it.resultSize; c++) {
+                    float result = 0.0f;
+                    float a0 = arg[0][sgl[0] ? 0 : c];
+                    float a1 = arg[1][sgl[1] ? 0 : c];
+
+                    switch(it.op) {
+                        case Mov: result = a0; break;
+                        case Add: result = a0 + a1; break;
+                        case Sub: result = a0 - a1; break;
+                        case Mul: result = a0 * a1; break;
+                        case Div: result = a0 / a1; break;
+                        default: break;
+                    }
+
+                    ret[c] = result;
+                }
+            }
+        }
+    }
+}
+/*!
+    \internal
+*/
+void VisualEffect::loadUserData(const VariantMap &data) {
+    PROFILE_FUNCTION();
+
+    Resource::loadUserData(data);
+
+    auto section = data.find(gEmitters);
+    if(section != data.end()) {
+        VariantList list = (*section).second.value<VariantList>();
+        for(auto &e : list) {
+            VariantList fields = e.value<VariantList>();
+            auto it = fields.begin();
+
+            setMesh(Engine::loadResource<Mesh>((*it).toString()));
+            it++;
+            setMaterial(Engine::loadResource<Material>((*it).toString()));
+            it++;
+            setGpu((*it).toBool());
+            it++;
+            setLocal((*it).toBool());
+            it++;
+            setContinous((*it).toBool());
+            it++;
+            setCapacity((*it).toInt());
+            it++;
+            setSpawnRate((*it).toFloat());
+            it++;
+            m_particleStride = (*it).toInt();
+            it++;
+
+            loadOperations((*it).value<VariantList>(), m_spawnOperations);
+            it++;
+            loadOperations((*it).value<VariantList>(), m_updateOperations);
+            it++;
+            loadOperations((*it).value<VariantList>(), m_renderOperations);
+        }
+    }
+}
+/*!
+    \internal
+*/
+void VisualEffect::loadOperations(const VariantList &list, std::vector<Operator> &operations) {
+    operations.clear();
+
+    for(auto it : list) {
+        VariantList fields = it.value<VariantList>();
+
+        Operator op;
+        auto field = fields.begin();
+        op.op = static_cast<Operation>((*field).toInt());
+        field++;
+        op.resultSpace = (*field).toInt();
+        field++;
+        op.resultOffset = (*field).toInt();
+        field++;
+        op.resultSize = (*field).toInt();
+        field++;
+
+        for(Variant arg : (*field).value<VariantList>()) {
+            VariantList argFields = arg.value<VariantList>();
+
+            auto argField = argFields.begin();
+
+            Argument argument;
+
+            argument.space = (*argField).toInt();
+            argField++;
+            argument.size = (*argField).toInt();
+            argField++;
+            argument.offset = -1;
+            switch(argument.space) {
+                case Constant: {
+                    op.constData.resize(op.resultSize);
+
+                    for(int i = 0; i < op.resultSize; i++) {
+                        op.constData[i] = (*argField).toFloat();
+                        argField++;
+                    }
+                } break;
+                case Random: {
+                    Vector4 min;
+                    for(int i = 0; i < op.resultSize; i++) {
+                        min[i] = (*argField).toFloat();
+                        argField++;
+                    }
+
+                    Vector4 max;
+                    for(int i = 0; i < op.resultSize; i++) {
+                        max[i] = (*argField).toFloat();
+                        argField++;
+                    }
+
+                    op.constData.resize(m_capacity * op.resultSize);
+                    for(int p = 0; p < m_capacity; p++) {
+                        for(int i = 0; i < op.resultSize; i++) {
+                            op.constData[p * op.resultSize + i] = RANGE(min[i], max[i]);
+                        }
+                    }
+                } break;
+                default: {
+                    argument.offset = (*argField).toInt();
+                } break;
+            }
+
+            op.arguments.push_back(argument);
+        }
+
+        operations.push_back(op);
+    }
+}
diff --git a/engine/src/systems/rendersystem.cpp b/engine/src/systems/rendersystem.cpp
index f6566256e..1bcac841e 100644
--- a/engine/src/systems/rendersystem.cpp
+++ b/engine/src/systems/rendersystem.cpp
@@ -4,7 +4,7 @@
 #include "components/meshrender.h"
 #include "components/textrender.h"
 #include "components/spriterender.h"
-#include "components/particlerender.h"
+#include "components/effectrender.h"
 #include "components/directlight.h"
 #include "components/pointlight.h"
 #include "components/spotlight.h"
@@ -57,7 +57,7 @@ RenderSystem::RenderSystem() :
         SpotLight::registerClassFactory(this);
         AreaLight::registerClassFactory(this);
 
-        ParticleRender::registerClassFactory(this);
+        EffectRender::registerClassFactory(this);
 
         TileMapRender::registerClassFactory(this);
 
@@ -100,7 +100,7 @@ RenderSystem::~RenderSystem() {
         SpotLight::unregisterClassFactory(this);
         AreaLight::unregisterClassFactory(this);
 
-        ParticleRender::unregisterClassFactory(this);
+        EffectRender::unregisterClassFactory(this);
 
         TileMapRender::unregisterClassFactory(this);
 
diff --git a/engine/src/systems/resourcesystem.cpp b/engine/src/systems/resourcesystem.cpp
index 123286193..757f9d38d 100644
--- a/engine/src/systems/resourcesystem.cpp
+++ b/engine/src/systems/resourcesystem.cpp
@@ -19,7 +19,7 @@
 #include "resources/animationclip.h"
 #include "resources/animationstatemachine.h"
 #include "resources/translator.h"
-#include "resources/particleeffect.h"
+#include "resources/visualeffect.h"
 #include "resources/pipeline.h"
 #include "resources/pose.h"
 #include "resources/prefab.h"
@@ -59,7 +59,7 @@ ResourceSystem::ResourceSystem() {
     TileSet::registerClassFactory(this);
     TileMap::registerClassFactory(this);
 
-    ParticleEffect::registerClassFactory(this);
+    VisualEffect::registerClassFactory(this);
 
     AnimationStateMachine::registerSuper(this);
 
diff --git a/modules/editor/grapheditor/editor/graph/graphcontroller.cpp b/modules/editor/grapheditor/editor/graph/graphcontroller.cpp
index ad94676b8..a587d4e6b 100644
--- a/modules/editor/grapheditor/editor/graph/graphcontroller.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphcontroller.cpp
@@ -293,13 +293,16 @@ void GraphController::update() {
             }
         }
         if(!selection.empty()) {
-            // The order of calls is correct
             GraphNode *defaultNode = m_graph->defaultNode();
+            QList<QObject *> list;
             if(defaultNode) {
-                emit m_view->itemsSelected({ defaultNode });
-                m_graph->deleteNodes(selection);
-                setSelected({ defaultNode });
+                list.push_back(defaultNode);
             }
+
+            // The order of calls is correct
+            emit m_view->itemsSelected(list);
+            m_graph->deleteNodes(selection);
+            setSelected(list);
         }
     }
 }
diff --git a/modules/editor/grapheditor/editor/graph/graphnode.cpp b/modules/editor/grapheditor/editor/graph/graphnode.cpp
index e521a4274..9064b4c04 100644
--- a/modules/editor/grapheditor/editor/graph/graphnode.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphnode.cpp
@@ -148,7 +148,7 @@ QDomElement GraphNode::fromVariant(const QVariant &value, QDomDocument &xml) {
 
     switch(value.userType()) {
         case QMetaType::QColor: {
-            valueElement.setAttribute(gType, "Color");
+            valueElement.setAttribute(gType, "color");
 
             QColor col = value.value<QColor>();
             valueElement.appendChild(xml.createTextNode(QString::number(col.red()) + ", " +
@@ -158,25 +158,25 @@ QDomElement GraphNode::fromVariant(const QVariant &value, QDomDocument &xml) {
         } break;
         default: {
             if(value.canConvert<Template>()) {
-                valueElement.setAttribute(gType, "Template");
+                valueElement.setAttribute(gType, "template");
 
                 Template tmp = value.value<Template>();
                 valueElement.appendChild(xml.createTextNode(tmp.path + ", " + tmp.type));
             } else if(value.canConvert<Vector2>()) {
-                valueElement.setAttribute(gType, "Vector2");
+                valueElement.setAttribute(gType, "vec2");
 
                 Vector2 vec = value.value<Vector2>();
                 valueElement.appendChild(xml.createTextNode(QString::number(vec.x) + ", " +
                                                             QString::number(vec.y) ));
             } else if(value.canConvert<Vector3>()) {
-                valueElement.setAttribute(gType, "Vector3");
+                valueElement.setAttribute(gType, "vec3");
 
                 Vector3 vec = value.value<Vector3>();
                 valueElement.appendChild(xml.createTextNode(QString::number(vec.x) + ", " +
                                                             QString::number(vec.y) + ", " +
                                                             QString::number(vec.z) ));
             } else if(value.canConvert<Vector4>()) {
-                valueElement.setAttribute(gType, "Vector3");
+                valueElement.setAttribute(gType, "vec4");
 
                 Vector4 vec = value.value<Vector4>();
                 valueElement.appendChild(xml.createTextNode(QString::number(vec.x) + ", " +
@@ -200,41 +200,62 @@ QDomElement GraphNode::fromVariant(const QVariant &value, QDomDocument &xml) {
 QVariant GraphNode::toVariant(const QString &value, const QString &type) {
     QVariant result;
 
-    if(type == "bool") {
+    QStringList list = value.split(", ");
+
+    QString lowType = type.toLower();
+    if(lowType == "auto") {
+        static const QStringList types = {
+            "ivalid",
+            "float",
+            "vec2",
+            "vec3",
+            "vec4"
+        };
+
+        lowType = types.at(list.size());
+    }
+
+    if(lowType == "bool") {
         result = (value == "true");
-    } else if(type == "int") {
+    } else if(lowType == "int") {
         result = value.toInt();
-    } else if(type == "float") {
+    } else if(lowType == "float") {
         result = value.toFloat();
-    } else if(type == "string") {
+    } else if(lowType == "string") {
         result = value;
-    } else if(type == "Vector2") {
-        QStringList list = value.split(", ");
-
-        result = QVariant::fromValue(Vector2(list.at(0).toFloat(),
-                                             list.at(1).toFloat()));
-    } else if(type == "Vector3") {
-        QStringList list = value.split(", ");
-
-        result = QVariant::fromValue(Vector3(list.at(0).toFloat(),
-                                             list.at(1).toFloat(),
-                                             list.at(2).toFloat()));
-    } else if(type == "Vector4") {
-        QStringList list = value.split(", ");
-
-        result = QVariant::fromValue(Vector4(list.at(0).toFloat(),
-                                             list.at(1).toFloat(),
-                                             list.at(2).toFloat(),
-                                             list.at(3).toFloat()));
-    } else if(type == "Template") {
-        QStringList list = value.split(", ");
-
-        result = QVariant::fromValue(Template(list.at(0), list.at(1).toUInt()));
-    } else if(type == "Color") {
-        QStringList list = value.split(", ");
-
-        result = QColor(list.at(0).toInt(), list.at(1).toInt(),
-                        list.at(2).toInt(), list.at(3).toInt());
+    } else if(lowType == "vector2" || lowType == "vec2") {
+        if(list.size() == 2) {
+            result = QVariant::fromValue(Vector2(list.at(0).toFloat(),
+                                                 list.at(1).toFloat()));
+        } else {
+            result = QVariant::fromValue(Vector2());
+        }
+    } else if(lowType == "vector3" || lowType == "vec3") {
+        if(list.size() == 3) {
+            result = QVariant::fromValue(Vector3(list.at(0).toFloat(),
+                                                 list.at(1).toFloat(),
+                                                 list.at(2).toFloat()));
+        } else {
+            result = QVariant::fromValue(Vector3());
+        }
+    } else if(lowType == "vector4" || lowType == "vec4") {
+        if(list.size() == 4) {
+            result = QVariant::fromValue(Vector4(list.at(0).toFloat(),
+                                                 list.at(1).toFloat(),
+                                                 list.at(2).toFloat(),
+                                                 list.at(3).toFloat()));
+        } else {
+            result = QVariant::fromValue(Vector4());
+        }
+    } else if(lowType == "template") {
+        result = QVariant::fromValue(Template(list.at(0), list.at(1)));
+    } else if(lowType == "color") {
+        if(list.size() == 4) {
+            result = QColor(list.at(0).toInt(), list.at(1).toInt(),
+                            list.at(2).toInt(), list.at(3).toInt());
+        } else {
+            result = QColor();
+        }
     }
 
     return result;
@@ -353,7 +374,7 @@ void GraphNode::loadUserData(const QVariantMap &data) {
                                                     array.at(3).toInt(), array.at(4).toInt() ));
             } else if(type == "Template") {
                 setProperty(qPrintable(key), QVariant::fromValue(Template(array.at(1).toString(),
-                                                                          array.at(2).toUInt() )));
+                                                                          array.at(2).toString() )));
             } else if(type == "Vector2") {
                 setProperty(qPrintable(key), QVariant::fromValue(Vector2(array.at(1).toFloat(),
                                                                          array.at(2).toFloat() )));
diff --git a/modules/editor/grapheditor/editor/graph/graphnode.h b/modules/editor/grapheditor/editor/graph/graphnode.h
index b34b4e1a9..b4e578ace 100644
--- a/modules/editor/grapheditor/editor/graph/graphnode.h
+++ b/modules/editor/grapheditor/editor/graph/graphnode.h
@@ -101,11 +101,12 @@ class NODEGRAPH_EXPORT GraphNode : public QObject {
     virtual void saveUserData(QVariantMap &data);
     virtual void loadUserData(const QVariantMap &data);
 
+    static QVariant toVariant(const QString &value, const QString &type);
+
 signals:
     void updated();
 
 protected:
-    QVariant toVariant(const QString &value, const QString &type);
     QDomElement fromVariant(const QVariant &value, QDomDocument &xml);
 
     void onNameChanged();
diff --git a/modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp b/modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp
index 84d228605..dbeaffdac 100644
--- a/modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp
@@ -22,6 +22,8 @@
 
 #include <input.h>
 
+#include "../statenode.h"
+
 const float row = 20.0f;
 
 namespace {
@@ -110,7 +112,7 @@ void NodeWidget::update() {
 
         if(hoveredRect == m_title->rectTransform() && Input::isMouseButtonDown(Input::MOUSE_LEFT)) {
             emitSignal(_SIGNAL(pressed()));
-        } else if(m_node) {
+        } else if(dynamic_cast<StateNode *>(m_node)) {
             bool hover = (hoveredRect == rectTransform());
             if(m_hovered != hover) {
                 m_hovered = hover;
diff --git a/modules/editor/motiontools/converter/animationcontrollergraph.cpp b/modules/editor/motiontools/converter/animationcontrollergraph.cpp
index e8a516c96..bb04206b3 100644
--- a/modules/editor/motiontools/converter/animationcontrollergraph.cpp
+++ b/modules/editor/motiontools/converter/animationcontrollergraph.cpp
@@ -32,8 +32,8 @@ void AnimationControllerGraph::loadGraphV0(const QVariantMap &data) {
 
     GraphNode *initial = nullptr;
 
-    int32_t entry = data[gEntry].toInt();
-    if(entry > -1) {
+    int32_t entry = data.value(gEntry, -1).toInt();
+    if(entry > -1 && m_nodes.size() > entry + 1) {
         initial = m_nodes.at(entry + 1);
     }
 
@@ -48,8 +48,8 @@ void AnimationControllerGraph::loadGraphV11(const QDomElement &parent) {
     if(parent.tagName() == gUser) {
         GraphNode *initial = nullptr;
 
-        int32_t entry = parent.attribute(gEntry).toInt();
-        if(entry > -1) {
+        int32_t entry = parent.attribute(gEntry, "-1").toInt();
+        if(entry > -1 && m_nodes.size() > entry + 1) {
             initial = m_nodes.at(entry + 1);
         }
 
diff --git a/modules/editor/motiontools/converter/basestate.cpp b/modules/editor/motiontools/converter/basestate.cpp
index 41da3e8d6..2c19168c7 100644
--- a/modules/editor/motiontools/converter/basestate.cpp
+++ b/modules/editor/motiontools/converter/basestate.cpp
@@ -9,7 +9,7 @@ namespace {
 }
 
 BaseState::BaseState() :
-        m_path(Template("", MetaType::type<AnimationClip *>())),
+        m_path(Template("", MetaType::name<AnimationClip>())),
         m_loop(false) {
 }
 
diff --git a/modules/editor/motiontools/converter/entrystate.h b/modules/editor/motiontools/converter/entrystate.h
index 630c83834..855d09a92 100644
--- a/modules/editor/motiontools/converter/entrystate.h
+++ b/modules/editor/motiontools/converter/entrystate.h
@@ -7,6 +7,8 @@ class EntryState : public StateNode {
     Q_OBJECT
 
 private:
+    bool isRemovable() const override { return false; }
+
     Vector2 defaultSize() const override;
     Vector4 color() const override;
 
diff --git a/modules/editor/particletools/converter/effectbuilder.cpp b/modules/editor/particletools/converter/effectbuilder.cpp
new file mode 100644
index 000000000..33c4f21b8
--- /dev/null
+++ b/modules/editor/particletools/converter/effectbuilder.cpp
@@ -0,0 +1,263 @@
+#include "effectbuilder.h"
+
+#include <QFile>
+
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+
+#include <bson.h>
+
+#include <actor.h>
+#include <effectrender.h>
+
+#include <mesh.h>
+#include <material.h>
+#include <visualeffect.h>
+
+#include "effectrootnode.h"
+#include "effectmodule.h"
+
+Q_DECLARE_METATYPE(Vector2)
+Q_DECLARE_METATYPE(Vector3)
+Q_DECLARE_METATYPE(Vector4)
+
+namespace  {
+    const char *gEffectRender("EffectRender");
+
+    // Old file format
+    const char *gName("Name");
+    const char *gMesh("Mesh");
+    const char *gMaterial("Material");
+
+    const char *gContinuous("Continuous");
+    const char *gLocal("Local");
+    const char *gGpu("Gpu");
+    const char *gCapacity("Capacity");
+    const char *gDistribution("Distribution");
+    const char *gFunctions("Functions");
+    const char *gClass("Class");
+    const char *gType("Type");
+    const char *gMin("Min");
+    const char *gMax("Max");
+};
+
+#define FORMAT_VERSION 10
+
+EffectBuilderSettings::EffectBuilderSettings() :
+        m_thumbnailWarmup(1.0f) {
+    setType(MetaType::type<VisualEffect *>());
+    setVersion(FORMAT_VERSION);
+}
+
+QString EffectBuilderSettings::defaultIcon(QString) const {
+    return ":/Style/styles/dark/images/effect.svg";
+}
+
+float EffectBuilderSettings::thumbnailWarmup() const {
+    return m_thumbnailWarmup;
+}
+void EffectBuilderSettings::setThumbnailWarmup(float value) {
+    if(m_thumbnailWarmup != value) {
+        m_thumbnailWarmup = value;
+        emit updated();
+    }
+}
+
+EffectBuilder::EffectBuilder() {
+    connect(&m_graph, &EffectGraph::effectUpdated, this, &EffectBuilder::effectUpdated);
+}
+
+int EffectBuilder::version() {
+    return FORMAT_VERSION;
+}
+
+AssetConverter::ReturnCode EffectBuilder::convertFile(AssetConverterSettings *settings) {
+    QFileInfo info(settings->source());
+    if(info.suffix() == "efx" && settings->currentVersion() == 2) {
+        convertOld(settings->source());
+        m_graph.save(settings->source());
+    } else {
+        m_graph.load(settings->source());
+    }
+
+    QFile file(settings->absoluteDestination());
+    if(file.open(QIODevice::WriteOnly)) {
+        ByteArray data = Bson::save( m_graph.object() );
+        file.write(reinterpret_cast<const char *>(data.data()), data.size());
+        file.close();
+
+        return Success;
+    }
+    return InternalError;
+}
+
+AssetConverterSettings *EffectBuilder::createSettings() {
+    return new EffectBuilderSettings();
+}
+
+Actor *EffectBuilder::createActor(const AssetConverterSettings *settings, const QString &guid) const {
+    const EffectBuilderSettings *s = static_cast<const EffectBuilderSettings *>(settings);
+    Actor *actor = Engine::composeActor(gEffectRender, "");
+    EffectRender *effect = static_cast<EffectRender *>(actor->component(gEffectRender));
+    if(effect) {
+        effect->setEffect(Engine::loadResource<VisualEffect>(guid.toStdString()));
+        float warmup = s->thumbnailWarmup();
+        const float frameStep = 1.0f / 60.0f;
+
+        while(warmup > 0.0f) {
+            effect->deltaUpdate(frameStep);
+            warmup -= frameStep;
+        }
+    }
+    return actor;
+}
+
+void EffectBuilder::convertOld(const QString &path) {
+    QFile loadFile(path);
+    if (!loadFile.open(QIODevice::ReadOnly)) {
+        qWarning("Couldn't open file.");
+        return;
+    }
+
+    m_graph.onNodesLoaded();
+    EffectRootNode *root = m_graph.rootNode();
+    root->removeAllModules();
+
+    QJsonDocument doc(QJsonDocument::fromJson(loadFile.readAll()));
+
+    QJsonArray nodes = doc.array();
+    for(int i = 0; i < nodes.size(); ++i) {
+        QJsonObject emitter = nodes[i].toObject();
+
+        root->setObjectName(emitter[gName].toString());
+
+        root->setGpu(emitter[gGpu].toBool());
+        root->setLocal(emitter[gLocal].toBool());
+        root->setContinuous(emitter[gContinuous].toBool());
+        root->setSpawnRate(static_cast<float>(emitter[gDistribution].toDouble()));
+
+        QJsonValue capacity = emitter.value(gCapacity);
+        if(!capacity.isUndefined()) {
+            root->setCapacity(capacity.toInt());
+        }
+
+        const static QMap<QString, QString> modulesMaper = {
+            {"Lifetime", "InitializeParticle"},
+            {"StartPosition", "InitializeParticle"},
+            {"StartSize", "InitializeParticle"},
+            {"StartColor", "InitializeParticle"},
+            {"StartAngle", "InitializeParticle"},
+
+            {"ScaleSize", "SizeScale"},
+            {"ScaleColor", "ColorScale"},
+            {"ScaleAngle", "RotationRate"},
+            {"Velocity", "AddVelocity"}
+        };
+
+        const static QMap<QString, QString> parametersMaper = {
+            {"Lifetime", "lifetime"},
+            {"StartPosition", "position"},
+            {"StartSize", "size"},
+            {"StartColor", "color"},
+            {"StartAngle", "rotation"},
+
+            {"ScaleSize", "sizeScale"},
+            {"ScaleColor", "colorScale"},
+            {"ScaleAngle", "rotationRate"},
+            {"Velocity", "velocitySpeed"},
+        };
+
+        enum Types {
+            Constant,
+            Random
+        };
+
+        QMap<std::string, EffectModule *> modules;
+
+        QJsonArray functions = emitter[gFunctions].toArray();
+        for(int m = 0; m < functions.size(); ++m) {
+            QJsonObject function = functions[m].toObject();
+
+            QString origin = function[gClass].toString();
+
+            QString classType = modulesMaper.value(origin);
+
+            EffectModule *module = modules.value(classType.toStdString());
+            if(module == nullptr) {
+                module = root->addModule(m_graph.modulePath(classType).toStdString());
+            }
+
+            if(module) {
+                modules[classType.toStdString()] = module;
+
+                QString param = parametersMaper.value(origin);
+                EffectModule::ParameterData *data = module->parameter(param.toStdString());
+                if(data) {
+                    int type = function[gType].toInt();
+
+                    if(type >= Constant) {
+                        data->mode.current = "Constant";
+
+                        QJsonObject min = function[gMin].toObject();
+                        QJsonArray minValue = min["Vector4"].toArray();
+                        Vector4 v(static_cast<float>(minValue.at(0).toDouble()),
+                                  static_cast<float>(minValue.at(1).toDouble()),
+                                  static_cast<float>(minValue.at(2).toDouble()),
+                                  static_cast<float>(minValue.at(3).toDouble()));
+
+                        if(data->min.canConvert<Vector2>()) {
+                            data->min = QVariant::fromValue(Vector2(v.x, v.y));
+                        } else if(data->min.canConvert<Vector3>()) {
+                            data->min = QVariant::fromValue(Vector3(v.x, v.y, v.z));
+                        } else if(data->min.canConvert<Vector4>()) {
+                            data->min = QVariant::fromValue(v);
+                        } else {
+                            data->min = v.x;
+                        }
+
+                        if(type == Random) {
+                            data->mode.current = "Random";
+
+                            QJsonObject max = function[gMax].toObject();
+                            QJsonArray maxValue = max["Vector4"].toArray();
+                            Vector4 v(static_cast<float>(maxValue.at(0).toDouble()),
+                                      static_cast<float>(maxValue.at(1).toDouble()),
+                                      static_cast<float>(maxValue.at(2).toDouble()),
+                                      static_cast<float>(maxValue.at(3).toDouble()));
+
+                            if(data->max.canConvert<Vector2>()) {
+                                data->max = QVariant::fromValue(Vector2(v.x, v.y));
+                            } else if(data->max.canConvert<Vector3>()) {
+                                data->max = QVariant::fromValue(Vector3(v.x, v.y, v.z));
+                            } else if(data->max.canConvert<Vector4>()) {
+                                data->max = QVariant::fromValue(v);
+                            } else {
+                                data->max = v.x;
+                            }
+                        }
+                    }
+                }
+
+                module->setRoot(root);
+            }
+        }
+
+        root->addModule(m_graph.modulePath("UpdateState").toStdString());
+        root->addModule(m_graph.modulePath("ResolveVelocity").toStdString());
+        EffectModule *render = root->addModule(m_graph.modulePath("SpriteRender").toStdString());
+        if(render) {
+            EffectModule::ParameterData *data = render->parameter("material");
+            if(data) {
+                data->min = QVariant::fromValue(Template(emitter[gMaterial].toString(), MetaType::name<Material>()));
+            }
+
+            data = render->parameter("mesh");
+            if(data) {
+                data->min = QVariant::fromValue(Template(emitter[gMesh].toString(), MetaType::name<Mesh>()));
+            }
+
+            render->setRoot(root);
+        }
+    }
+}
diff --git a/modules/editor/particletools/converter/effectbuilder.h b/modules/editor/particletools/converter/effectbuilder.h
new file mode 100644
index 000000000..328d37cb3
--- /dev/null
+++ b/modules/editor/particletools/converter/effectbuilder.h
@@ -0,0 +1,57 @@
+#ifndef EFFECTBUILDER_H
+#define EFFECTBUILDER_H
+
+#include <editor/assetconverter.h>
+
+#include "effectgraph.h"
+
+class EffectBuilderSettings : public AssetConverterSettings {
+    Q_OBJECT
+
+    Q_PROPERTY(float thumbnailWarmup READ thumbnailWarmup WRITE setThumbnailWarmup DESIGNABLE true USER true)
+
+public:
+    EffectBuilderSettings();
+
+    float thumbnailWarmup() const;
+    void setThumbnailWarmup(float value);
+
+private:
+    QString defaultIcon(QString) const Q_DECL_OVERRIDE;
+
+private:
+    float m_thumbnailWarmup;
+
+};
+
+class EffectBuilder : public AssetConverter {
+    Q_OBJECT
+
+public:
+    EffectBuilder();
+
+    static int version();
+
+    QStringList suffixes() const override { return {"vfx", "efx"}; }
+
+    EffectGraph &graph() { return m_graph; }
+
+protected:
+    ReturnCode convertFile(AssetConverterSettings *) override;
+    AssetConverterSettings *createSettings() override;
+
+    Actor *createActor(const AssetConverterSettings *settings, const QString &guid) const override;
+
+    QString templatePath() const override { return ":/templates/VisualEffect.vfx"; }
+
+    void convertOld(const QString &path);
+
+signals:
+    void effectUpdated();
+
+private:
+    EffectGraph m_graph;
+
+};
+
+#endif // EFFECTBUILDER_H
diff --git a/modules/editor/particletools/converter/effectconverter.cpp b/modules/editor/particletools/converter/effectconverter.cpp
deleted file mode 100644
index 4b83fa63f..000000000
--- a/modules/editor/particletools/converter/effectconverter.cpp
+++ /dev/null
@@ -1,400 +0,0 @@
-#include "effectconverter.h"
-
-#include <QFile>
-#include <QJsonDocument>
-#include <QJsonObject>
-#include <QJsonArray>
-
-#include <bson.h>
-
-#include <actor.h>
-#include <particlerender.h>
-
-#include <mesh.h>
-#include <material.h>
-#include <particleeffect.h>
-
-#define NAME        "Name"
-#define MESH        "Mesh"
-#define MATERIAL    "Material"
-#define CONTINUOUS  "Continuous"
-#define LOCAL       "Local"
-#define GPU         "Gpu"
-#define CAPACITY    "Capacity"
-#define DISTRIBUTION "Distribution"
-#define FUNCTIONS   "Functions"
-#define CLASS       "Class"
-#define TYPE        "Type"
-#define MINIMUM     "Min"
-#define MAXIMUM     "Max"
-
-#define EMITTERS    "Emitters"
-#define FORMAT_VERSION 2
-
-EffectConverterSettings::EffectConverterSettings() :
-    m_thumbnailWarmup(1.0f) {
-    setType(MetaType::type<ParticleEffect *>());
-    setVersion(FORMAT_VERSION);
-}
-
-QString EffectConverterSettings::defaultIcon(QString) const {
-    return ":/Style/styles/dark/images/effect.svg";
-}
-
-float EffectConverterSettings::thumbnailWarmup() const {
-    return m_thumbnailWarmup;
-}
-void EffectConverterSettings::setThumbnailWarmup(float value) {
-    if(m_thumbnailWarmup != value) {
-        m_thumbnailWarmup = value;
-        emit updated();
-    }
-}
-
-EffectConverter::EffectConverter() {
-    qRegisterMetaType<EffectEmitter*>("EffectEmitter*");
-
-    qRegisterMetaType<Lifetime*>("Lifetime");
-    qRegisterMetaType<StartSize*>("StartSize");
-    qRegisterMetaType<StartColor*>("StartColor");
-    qRegisterMetaType<StartAngle*>("StartAngle");
-    qRegisterMetaType<StartPosition*>("StartPosition");
-
-    qRegisterMetaType<ScaleSize*>("ScaleSize");
-    qRegisterMetaType<ScaleColor*>("ScaleColor");
-    qRegisterMetaType<ScaleAngle*>("ScaleAngle");
-    qRegisterMetaType<Velocity*>("Velocity");
-}
-
-AssetConverter::ReturnCode EffectConverter::convertFile(AssetConverterSettings *settings) {
-    load(settings->source());
-
-    if(settings->currentVersion() != FORMAT_VERSION) {
-        save(settings->source());
-    }
-
-    QFile file(settings->absoluteDestination());
-    if(file.open(QIODevice::WriteOnly)) {
-        ByteArray data = Bson::save( object() );
-        file.write(reinterpret_cast<const char *>(&data[0]), data.size());
-        file.close();
-        return Success;
-    }
-
-    return InternalError;
-}
-
-AssetConverterSettings *EffectConverter::createSettings() {
-    return new EffectConverterSettings();
-}
-
-Actor *EffectConverter::createActor(const AssetConverterSettings *settings, const QString &guid) const {
-    const EffectConverterSettings *s = static_cast<const EffectConverterSettings *>(settings);
-    Actor *actor = Engine::composeActor("ParticleRender", "");
-    ParticleRender *effect = static_cast<ParticleRender *>(actor->component("ParticleRender"));
-    if(effect) {
-        effect->setEffect(Engine::loadResource<ParticleEffect>(guid.toStdString()));
-        float warmup = s->thumbnailWarmup();
-        const float frameStep = 1.0f / 60.0f;
-        while(warmup > 0.0f) {
-            effect->deltaUpdate(frameStep);
-            warmup -= frameStep;
-        }
-    }
-    return actor;
-}
-
-void EffectConverter::load(const QString &path) {
-    foreach(QObject *it, children()) {
-        delete it;
-    }
-
-    QFile loadFile(path);
-    if (!loadFile.open(QIODevice::ReadOnly)) {
-        qWarning("Couldn't open file.");
-        return;
-    }
-
-    QJsonDocument doc(QJsonDocument::fromJson(loadFile.readAll()));
-
-    QJsonArray nodes = doc.array();
-    for(int i = 0; i < nodes.size(); ++i) {
-        QJsonObject emitter = nodes[i].toObject();
-
-        EffectEmitter *obj = new EffectEmitter(this);
-        obj->blockSignals(true);
-        obj->setObjectName(emitter[NAME].toString());
-
-        obj->setMeshPath(emitter[MESH].toString());
-        obj->setMaterialPath(emitter[MATERIAL].toString());
-
-        QJsonValue capacity = emitter.value(CAPACITY);
-        if(!capacity.isUndefined()) {
-            obj->setCapacity(capacity.toInt());
-        }
-
-        obj->setDistribution(static_cast<float>(emitter[DISTRIBUTION].toDouble()));
-
-        obj->setGpu(emitter[GPU].toBool());
-        obj->setLocal(emitter[LOCAL].toBool());
-        obj->setContinuous(emitter[CONTINUOUS].toBool());
-
-        connect(obj, &EffectEmitter::updated, this, &EffectConverter::effectUpdated);
-
-        obj->blockSignals(false);
-
-        QJsonArray functions = emitter[FUNCTIONS].toArray();
-        for(int m = 0; m < functions.size(); ++m) {
-            QJsonObject function = functions[m].toObject();
-
-            QString meta = function[CLASS].toString();
-
-            EffectFunction *mod = createFunction(meta);
-            if(mod) {
-                mod->blockSignals(true);
-                mod->setParent(obj);
-                mod->setObjectName(meta);
-
-                mod->setType(static_cast<EffectFunction::ModificatorType>(function[TYPE].toInt()));
-
-                if(mod->type() <= EffectFunction::Range) {
-                    {
-                        QJsonObject min = function[MINIMUM].toObject();
-                        QJsonArray v = min["Vector4"].toArray();
-                        mod->setMin(Vector4(static_cast<float>(v.at(0).toDouble()),
-                                            static_cast<float>(v.at(1).toDouble()),
-                                            static_cast<float>(v.at(2).toDouble()),
-                                            static_cast<float>(v.at(3).toDouble())));
-                    }
-                    if(function[TYPE].toInt() == EffectFunction::Range) {
-                        QJsonObject max = function[MAXIMUM].toObject();
-                        QJsonArray v = max["Vector4"].toArray();
-                        mod->setMax(Vector4(static_cast<float>(v.at(0).toDouble()),
-                                            static_cast<float>(v.at(1).toDouble()),
-                                            static_cast<float>(v.at(2).toDouble()),
-                                            static_cast<float>(v.at(3).toDouble())));
-                    }
-                } else {
-
-                }
-                mod->blockSignals(false);
-            }
-        }
-    }
-}
-
-void EffectConverter::save(const QString &path) {
-    QFile saveFile(path);
-    if(!saveFile.open(QIODevice::WriteOnly)) {
-        qWarning("Couldn't open file.");
-        return;
-    }
-
-    QJsonArray nodes;
-    foreach(auto *it, children()) {
-        const EffectEmitter *e = dynamic_cast<const EffectEmitter *>(it);
-        if(e) {
-            QJsonObject emitter;
-
-            emitter[NAME] = e->objectName();
-            emitter[MESH] = e->meshPath();
-            emitter[MATERIAL] = e->materialPath();
-
-            emitter[CAPACITY] = static_cast<int>(e->capacity());
-            emitter[DISTRIBUTION] = static_cast<double>(e->distribution());
-
-            emitter[GPU] = e->isGpu();
-            emitter[LOCAL] = e->isLocal();
-            emitter[CONTINUOUS] = e->isContinuous();
-
-
-            QJsonArray functions;
-            foreach(auto *obj, it->children()) {
-                const EffectFunction *mod = dynamic_cast<const EffectFunction *>(obj);
-                if(mod) {
-                    QJsonObject function;
-                    function[CLASS] = mod->metaObject()->className();
-                    function[TYPE] = mod->type();
-                    if(mod->type() <= EffectFunction::Range) {
-                        {
-                            QJsonObject min;
-                            QJsonArray vector;
-                            Vector4 v = mod->min();
-                            vector.push_back(static_cast<double>(v.x));
-                            vector.push_back(static_cast<double>(v.y));
-                            vector.push_back(static_cast<double>(v.z));
-                            vector.push_back(static_cast<double>(v.w));
-
-                            min["Vector4"] = vector;
-                            function[MINIMUM] = min;
-                        }
-                        if(mod->type() == EffectFunction::Range) {
-                            QJsonObject max;
-                            QJsonArray vector;
-                            Vector4 v = mod->max();
-                            vector.push_back(static_cast<double>(v.x));
-                            vector.push_back(static_cast<double>(v.y));
-                            vector.push_back(static_cast<double>(v.z));
-                            vector.push_back(static_cast<double>(v.w));
-
-                            max["Vector4"] = vector;
-                            function[MAXIMUM] = max;
-                        }
-                    } else {
-
-                    }
-                    functions.push_back(function);
-                }
-            }
-            emitter[FUNCTIONS] = functions;
-            nodes.push_back(emitter);
-        }
-    }
-    QJsonDocument doc(nodes);
-    saveFile.write(doc.toJson());
-}
-
-Variant EffectConverter::data() const {
-    VariantMap user;
-
-    VariantList emitters;
-    foreach(QObject *child, children()) {
-        EffectEmitter *e = dynamic_cast<EffectEmitter *>(child);
-        if(e) {
-            VariantList emitter;
-
-            emitter.push_back( e->meshPath().toStdString() );
-            emitter.push_back( e->materialPath().toStdString() );
-
-            emitter.push_back(e->isGpu());
-            emitter.push_back(e->isLocal());
-            emitter.push_back(e->isContinuous());
-
-            emitter.push_back(e->capacity());
-            emitter.push_back(e->distribution());
-
-            VariantList modificators;
-
-            foreach(QObject *mod, e->children()) {
-                EffectFunction *m = dynamic_cast<EffectFunction *>(mod);
-                if(m) {
-                    VariantList modificator;
-
-                    int32_t type = m->type();
-                    modificator.push_back(m->classType());
-
-                    VariantList data;
-                    data.push_back(type);
-
-                    if(type <= EffectFunction::Range) {
-                        data.push_back(m->min());
-                        if(type == EffectFunction::Range) {
-                            data.push_back(m->max());
-                        }
-                    } else {
-
-                    }
-                    modificator.push_back(data);
-                    modificators.push_back(modificator);
-                }
-            }
-            emitter.push_back(modificators);
-            emitters.push_back(emitter);
-        }
-    }
-    user[EMITTERS] = emitters;
-
-    return user;
-}
-
-EffectEmitter *EffectConverter::createEmitter() {
-    EffectEmitter *obj = new EffectEmitter(this);
-    QString base = "Emitter";
-    uint32_t it = 1;
-    while(findChild<EffectEmitter *>(base + QString::number(it), Qt::FindDirectChildrenOnly) != nullptr) {
-        it++;
-    }
-    obj->setObjectName(base + QString::number(it));
-    obj->setMeshPath(".embedded/sphere.fbx/Sphere001");
-    connect(obj, &EffectEmitter::updated, this, &EffectConverter::effectUpdated);
-    emit effectUpdated();
-    return obj;
-}
-
-void EffectConverter::deleteEmitter(QString name) {
-    EffectEmitter *emitter  = findChild<EffectEmitter *>(name, Qt::FindDirectChildrenOnly);
-    if(emitter) {
-        emitter->setParent(nullptr);
-        emitter->deleteLater();
-        emitter = nullptr;
-    }
-    emit effectUpdated();
-}
-
-EffectFunction *EffectConverter::createFunction(const QString &name, const QString &path) {
-    EffectEmitter *emitter  = findChild<EffectEmitter *>(name, Qt::FindDirectChildrenOnly);
-    if(emitter) {
-        EffectFunction *mod = createFunction(path);
-        if(mod) {
-            mod->blockSignals(true);
-
-            mod->setParent(emitter);
-            mod->setObjectName(path);
-
-            mod->blockSignals(false);
-
-            emit effectUpdated();
-            return mod;
-        }
-    }
-    return nullptr;
-}
-
-void EffectConverter::deleteFunction(const QString &name, const QString &path) {
-    EffectEmitter *emitter  = findChild<EffectEmitter *>(name, Qt::FindDirectChildrenOnly);
-    if(emitter) {
-        EffectFunction *mod = emitter->findChild<EffectFunction *>(path, Qt::FindDirectChildrenOnly);
-        if(mod) {
-            mod->setParent(nullptr);
-            mod->deleteLater();
-            mod = nullptr;
-        }
-    }
-    emit effectUpdated();
-}
-
-EffectFunction *EffectConverter::createFunction(const QString &path) {
-    const QByteArray className = qPrintable(path + "*");
-    const int type = QMetaType::type( className );
-    const QMetaObject *meta = QMetaType::metaObjectForType(type);
-    if(meta) {
-        QObject *object = meta->newInstance();
-        EffectFunction *function = dynamic_cast<EffectFunction *>(object);
-        if(function) {
-            connect(function, SIGNAL(updated()), this, SIGNAL(effectUpdated()));
-            return function;
-        }
-    }
-    return nullptr;
-}
-
-Variant EffectConverter::object() const {
-    VariantList result;
-
-    VariantList object;
-
-    object.push_back(ParticleEffect::metaClass()->name()); // type
-    object.push_back(0); // id
-    object.push_back(0); // parent
-    object.push_back(""); // name
-
-    object.push_back(VariantMap()); // properties
-
-    object.push_back(VariantList()); // links
-    object.push_back(data()); // user data
-
-    result.push_back(object);
-
-    return result;
-}
-
diff --git a/modules/editor/particletools/converter/effectconverter.h b/modules/editor/particletools/converter/effectconverter.h
deleted file mode 100644
index 0e016970b..000000000
--- a/modules/editor/particletools/converter/effectconverter.h
+++ /dev/null
@@ -1,301 +0,0 @@
-#ifndef EFFECTCONVERTER_H
-#define EFFECTCONVERTER_H
-
-#include <QObject>
-#include <QColor>
-#include <QVariant>
-
-#include <editor/assetconverter.h>
-#include <resources/particleeffect.h>
-#include <resources/material.h>
-
-#include <editor/projectsettings.h>
-
-#include <metatype.h>
-
-class EffectFunction : public QObject {
-    Q_OBJECT
-    Q_CLASSINFO("Group", "Modificator")
-    Q_PROPERTY(ModificatorType Type READ type WRITE setType NOTIFY updated DESIGNABLE true USER true)
-
-public:
-    enum ModificatorType {
-        Constant = 0,
-        Range
-    };
-    Q_ENUM(ModificatorType)
-
-public:
-    Q_INVOKABLE EffectFunction() :
-            m_type(Constant) {
-
-    }
-
-    virtual int32_t classType() const { return 0; }
-
-    ModificatorType type() const { return m_type; }
-    void setType(ModificatorType type) { m_type = type; emit updated(); }
-
-    Vector4 min() const { return m_min; }
-    void setMin(const Vector4 &min) { m_min = min; emit updated(); }
-
-    Vector4 max() const { return m_max; }
-    void setMax(const Vector4 &max) { m_max = max; emit updated(); }
-
-    float minFloatValue() const { return m_min.x; }
-    void setFloatMinValue(float value) { m_min.x = value; emit updated(); }
-
-    float maxFloatValue() const { return m_max.x; }
-    void setFloatMaxValue(float value) { m_max.x = value; emit updated(); }
-
-    Vector3 minValue() const { return Vector3(m_min.x, m_min.y, m_min.z); }
-    void setMinValue(Vector3 value) { m_min = Vector4(value, m_min.w); emit updated(); }
-
-    Vector3 maxValue() const { return Vector3(m_max.x, m_max.y, m_max.z); }
-    void setMaxValue(Vector3 value) { m_max = Vector4(value, m_max.w); emit updated(); }
-
-    QColor minColorValue() const { return QColor::fromRgbF(m_min.x, m_min.y, m_min.z, m_min.z); }
-    void setColorMinValue(QColor value) { m_min = Vector4(value.redF(), value.greenF(), value.blueF(), value.alphaF()); emit updated(); }
-
-    QColor maxColorValue() const { return QColor::fromRgbF(m_max.x, m_max.y, m_max.z, m_max.z); }
-    void setColorMaxValue(QColor value) { m_max = Vector4(value.redF(), value.greenF(), value.blueF(), value.alphaF()); emit updated(); }
-
-signals:
-    void updated();
-
-protected:
-    ModificatorType m_type;
-
-    Vector4 m_min;
-    Vector4 m_max;
-
-};
-
-Q_DECLARE_METATYPE(EffectFunction::ModificatorType)
-
-class Lifetime : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(float Value READ minFloatValue WRITE setFloatMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(float Min READ minFloatValue WRITE setFloatMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(float Max READ maxFloatValue WRITE setFloatMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE Lifetime() { }
-    int32_t classType() const { return ParticleModificator::Lifetime; }
-};
-
-class StartSize : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(Vector3 Value READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Min READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Max READ maxValue WRITE setMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE StartSize() { }
-    int32_t classType() const { return ParticleModificator::Size; }
-};
-
-class StartColor : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(QColor Value READ minColorValue WRITE setColorMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(QColor Min READ minColorValue WRITE setColorMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(QColor Max READ maxColorValue WRITE setColorMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE StartColor() { }
-    int32_t classType() const { return ParticleModificator::Color; }
-};
-
-class StartAngle : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(Vector3 Value READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Min READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Max READ maxValue WRITE setMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE StartAngle() { }
-    int32_t classType() const { return ParticleModificator::Rotation; }
-};
-
-class StartPosition : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(Vector3 Value READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Min READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Max READ maxValue WRITE setMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE StartPosition() { }
-    int32_t classType() const { return ParticleModificator::Position; }
-};
-
-class ScaleSize : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(Vector3 Value READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Min READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Max READ maxValue WRITE setMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE ScaleSize() { }
-    int32_t classType() const { return ParticleModificator::ScaleSize; }
-};
-
-class ScaleColor : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(QColor Value READ minColorValue WRITE setColorMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(QColor Min READ minColorValue WRITE setColorMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(QColor Max READ maxColorValue WRITE setColorMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE ScaleColor() { }
-    virtual int32_t classType() const { return ParticleModificator::ScaleColor; }
-};
-
-class ScaleAngle : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(Vector3 Value READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Min READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Max READ maxValue WRITE setMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE ScaleAngle() { }
-    virtual int32_t classType() const { return ParticleModificator::ScaleRotation; }
-};
-
-class Velocity : public EffectFunction {
-    Q_OBJECT
-    Q_PROPERTY(Vector3 Value READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Min READ minValue WRITE setMinValue DESIGNABLE true USER true)
-    Q_PROPERTY(Vector3 Max READ maxValue WRITE setMaxValue DESIGNABLE true USER true)
-public:
-    Q_INVOKABLE Velocity() { }
-    virtual int32_t classType() const { return ParticleModificator::Velocity; }
-};
-
-class EffectEmitter : public QObject {
-    Q_OBJECT
-
-    Q_PROPERTY(QString Name READ objectName WRITE setName NOTIFY updated DESIGNABLE true USER true)
-    Q_PROPERTY(Template Material READ material WRITE setMaterial NOTIFY updated DESIGNABLE true USER true)
-
-    Q_PROPERTY(int Capacity READ capacity WRITE setCapacity NOTIFY updated DESIGNABLE true USER true)
-    Q_PROPERTY(float Distribution READ distribution WRITE setDistribution NOTIFY updated DESIGNABLE true USER true)
-
-    Q_PROPERTY(bool Local READ isLocal WRITE setLocal NOTIFY updated DESIGNABLE true USER true)
-    Q_PROPERTY(bool Continuous READ isContinuous WRITE setContinuous NOTIFY updated DESIGNABLE true USER true)
-
-    Q_PROPERTY(QVariant _ChildModel READ getFunctions NOTIFY updated DESIGNABLE true USER true)
-
-    Q_PROPERTY(QString _IconPath READ iconPath NOTIFY updated DESIGNABLE true USER true)
-
-public:
-    EffectEmitter(QObject *parent = nullptr) :
-            QObject(parent),
-            m_capacity(32),
-            m_distribution(1.0f),
-            m_gpu(false),
-            m_local(false),
-            m_continuous(true) {
-
-    }
-
-    void setName(const QString value) { setObjectName(value); emit updated();}
-
-    bool isGpu() const { return false; }
-    void setGpu(bool value) { m_gpu = value; emit updated(); }
-
-    bool isLocal() const { return m_local; }
-    void setLocal(bool value) { m_local = value; emit updated(); }
-
-    bool isContinuous() const { return m_continuous; }
-    void setContinuous(bool value) { m_continuous = value; emit updated(); }
-
-    float distribution() const { return m_distribution; }
-    void setDistribution(float value) { m_distribution = value; emit updated(); }
-
-    int capacity() const { return m_capacity; }
-    void setCapacity(int value) { m_capacity = value; emit updated(); }
-
-    Template mesh() const { return Template(m_meshPath, MetaType::type<Mesh *>()); }
-    void setMesh(Template mesh) { m_meshPath = mesh.path; emit updated(); }
-
-    Template material() const { return Template(m_materialPath, MetaType::type<Material *>()); }
-    void setMaterial(Template material) { m_materialPath = material.path; emit updated(); }
-
-    QString meshPath() const { return m_meshPath; }
-    void setMeshPath(const QString &path) { m_meshPath = path; emit updated(); }
-
-    QString materialPath() const { return m_materialPath; }
-    void setMaterialPath(const QString &path) { m_materialPath = path; emit updated(); }
-
-    QVariant getFunctions() const {
-        QStringList result;
-        foreach(QObject *it, children()) {
-            result.append(it->metaObject()->className());
-        }
-        return result;
-    }
-
-    QString iconPath() const { return ProjectSettings::instance()->iconPath() + "/" + m_materialPath + ".png"; }
-
-signals:
-    void updated();
-
-private:
-    int m_capacity;
-    float m_distribution;
-    bool m_gpu;
-    bool m_local;
-    bool m_continuous;
-
-    QString m_meshPath;
-    QString m_materialPath;
-
-};
-
-class EffectConverterSettings : public AssetConverterSettings {
-    Q_OBJECT
-
-    Q_PROPERTY(float thumbnailWarmup READ thumbnailWarmup WRITE setThumbnailWarmup DESIGNABLE true USER true)
-
-public:
-    EffectConverterSettings();
-
-    float thumbnailWarmup() const;
-    void setThumbnailWarmup(float value);
-
-private:
-    QString defaultIcon(QString) const override;
-
-private:
-    float m_thumbnailWarmup;
-
-};
-
-class EffectConverter : public AssetConverter {
-    Q_OBJECT
-
-public:
-    EffectConverter();
-    virtual ~EffectConverter() {}
-
-    void load(const QString &path);
-    void save(const QString &path);
-
-    EffectEmitter *createEmitter();
-    void deleteEmitter(QString name);
-
-    EffectFunction *createFunction(const QString &name, const QString &path);
-    void deleteFunction(const QString &name, const QString &path);
-
-    EffectFunction *createFunction(const QString &path);
-
-    Variant data() const;
-    Variant object() const;
-
-protected:
-    QStringList suffixes() const override { return {"efx"}; }
-    ReturnCode convertFile(AssetConverterSettings *) override;
-    AssetConverterSettings *createSettings() override;
-
-    Actor *createActor(const AssetConverterSettings *settings, const QString &guid) const override;
-
-    QString templatePath() const override { return ":/templates/ParticleEffect.efx"; }
-
-signals:
-    void effectUpdated();
-
-};
-
-#endif // EFFECTCONVERTER_H
diff --git a/modules/editor/particletools/converter/effectgraph.cpp b/modules/editor/particletools/converter/effectgraph.cpp
new file mode 100644
index 000000000..c28cd20f8
--- /dev/null
+++ b/modules/editor/particletools/converter/effectgraph.cpp
@@ -0,0 +1,186 @@
+#include "effectgraph.h"
+
+#include <QMenu>
+#include <QDirIterator>
+
+#include <editor/projectsettings.h>
+
+#include <resources/visualeffect.h>
+
+#include "effectrootnode.h"
+#include "effectbuilder.h"
+
+namespace {
+    const char *gEmitters("Emitters");
+};
+
+EffectGraph::EffectGraph() :
+        m_rootNode(nullptr),
+        m_menu(new QMenu) {
+
+    m_version = EffectBuilder::version();
+
+    scanForFunctions();
+
+    for(auto it : m_nodeTypes) {
+        QMenu *menu = m_menu;
+
+        QStringList list = it.split('/');
+        for(int i = 0; i < list.size(); i++) {
+            if(i == list.size() - 1) {
+                menu->addAction(list.at(i));
+            } else {
+                bool found = false;
+                for(auto it : menu->actions()) {
+                    if(it->text() == list.at(i)) {
+                        if(it->menu()) {
+                            found = true;
+                            menu = it->menu();
+                            break;
+                        }
+                    }
+                }
+                if(!found) {
+                    menu = menu->addMenu(list.at(i));
+                }
+            }
+        }
+    }
+}
+
+void EffectGraph::scanForFunctions() {
+    QStringList filter({"*.vfm"});
+
+    QStringList paths = {
+        ":/modules",
+        ProjectSettings::instance()->contentPath()
+    };
+
+    for(auto &path : paths) {
+        QStringList files;
+
+        QDirIterator it(path, filter, QDir::AllEntries | QDir::NoSymLinks | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
+        while(it.hasNext()) {
+            files << it.next();
+        }
+
+        for(auto &path : files) {
+            QFile file(path);
+            if(file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                QDomDocument doc;
+                if(doc.setContent(&file)) {
+                    QDomElement function = doc.documentElement();
+
+                    QString name = function.attribute("name");
+
+                    m_nodeTypes << name;
+                    m_exposedModules[QFileInfo(name).baseName()] = path;
+                }
+            }
+        }
+    }
+}
+
+GraphNode *EffectGraph::nodeCreate(const QString &path, int &index) {
+    if(path == "EffectRootNode") {
+        GraphNode *node = new EffectRootNode;
+        node->setGraph(this);
+        connect(node, &EffectRootNode::updated, this, &EffectGraph::effectUpdated);
+
+        if(index == -1) {
+            index = m_nodes.size();
+            m_nodes.push_back(node);
+        } else {
+            m_nodes.insert(index, node);
+        }
+
+        return node;
+    }
+
+    return nullptr;
+}
+
+void EffectGraph::onNodesLoaded() {
+    m_rootNode = nullptr;
+
+    for(auto it : m_nodes) {
+        EffectRootNode *entry = dynamic_cast<EffectRootNode *>(it);
+        if(entry) {
+            m_rootNode = entry;
+            break;
+        }
+    }
+
+    if(m_rootNode == nullptr) {
+        m_rootNode = new EffectRootNode;
+
+        m_rootNode->setObjectName("NewEffectEmitter");
+        m_rootNode->setGraph(this);
+        connect(m_rootNode, &EffectRootNode::updated, this, &EffectGraph::effectUpdated);
+
+        m_nodes.push_front(m_rootNode);
+    }
+}
+
+QStringList EffectGraph::nodeList() const {
+    return m_nodeTypes;
+}
+
+EffectRootNode *EffectGraph::rootNode() {
+    return m_rootNode;
+}
+
+QString EffectGraph::modulePath(QString name) {
+    auto it = m_exposedModules.find(name);
+    if(it != m_exposedModules.end()) {
+        return it->second;
+    }
+    return QString();
+}
+
+void EffectGraph::showFunctionsMenu() {
+    emit menuVisible(true);
+    if(!m_menu->isVisible()) {
+        QAction *action = m_menu->exec(QCursor::pos());
+        if(action) {
+            m_rootNode->addModule(m_exposedModules[action->text()].toStdString());
+            emit moduleChanged();
+        }
+    }
+    emit menuVisible(false);
+}
+
+VariantMap EffectGraph::data() const {
+    VariantMap user;
+
+    VariantList emitters;
+    for(GraphNode *node : m_nodes) {
+        EffectRootNode *rootNode = dynamic_cast<EffectRootNode *>(node);
+        if(rootNode) {
+            emitters.push_back(rootNode->saveData());
+        }
+    }
+    user[gEmitters] = emitters;
+
+    return user;
+}
+
+Variant EffectGraph::object() const {
+    VariantList result;
+
+    VariantList object;
+
+    object.push_back(VisualEffect::metaClass()->name()); // type
+    object.push_back(0); // id
+    object.push_back(0); // parent
+    object.push_back(""); // name
+
+    object.push_back(VariantMap()); // properties
+    object.push_back(VariantList()); // links
+
+    object.push_back(data()); // user data
+
+    result.push_back(object);
+
+    return result;
+}
diff --git a/modules/editor/particletools/converter/effectgraph.h b/modules/editor/particletools/converter/effectgraph.h
new file mode 100644
index 000000000..214782a1b
--- /dev/null
+++ b/modules/editor/particletools/converter/effectgraph.h
@@ -0,0 +1,52 @@
+#ifndef SHADERGRAPH_H
+#define SHADERGRAPH_H
+
+#include <editor/graph/graphnode.h>
+#include <editor/graph/abstractnodegraph.h>
+
+class EffectRootNode;
+class QMenu;
+
+class EffectGraph : public AbstractNodeGraph {
+    Q_OBJECT
+
+public:
+    EffectGraph();
+
+    VariantMap data() const;
+
+    Variant object() const;
+
+    QStringList nodeList() const override;
+
+    EffectRootNode *rootNode();
+
+    QString modulePath(QString name);
+
+signals:
+    void moduleChanged();
+
+    void effectUpdated();
+
+public slots:
+    void showFunctionsMenu();
+
+    void onNodesLoaded() override;
+
+private:
+    void scanForFunctions();
+
+    GraphNode *nodeCreate(const QString &path, int &index) override;
+
+private:
+    QStringList m_nodeTypes;
+
+    std::map<QString, QString> m_exposedModules;
+
+    EffectRootNode *m_rootNode;
+
+    QMenu *m_menu;
+
+};
+
+#endif // SHADERGRAPH_H
diff --git a/modules/editor/particletools/converter/effectmodule.cpp b/modules/editor/particletools/converter/effectmodule.cpp
new file mode 100644
index 000000000..f24d9cadd
--- /dev/null
+++ b/modules/editor/particletools/converter/effectmodule.cpp
@@ -0,0 +1,482 @@
+#include "effectmodule.h"
+
+#include <components/image.h>
+#include <components/frame.h>
+#include <components/label.h>
+#include <components/recttransform.h>
+#include <components/checkbox.h>
+
+#include <amath.h>
+
+#include <QVariant>
+#include <QEvent>
+#include <QColor>
+#include <QMetaEnum>
+
+#include <QDomDocument>
+
+#include "effectrootnode.h"
+
+namespace {
+    const char *gCheckBoxWidget("CheckBox");
+
+    const char *gValue("value");
+    const char *gMin("min");
+    const char *gMax("max");
+
+    const char *gRandom("random");
+    const char *gType("type");
+    const char *gName("name");
+
+    const char *gMode("Mode");
+};
+
+static const std::map<std::string, int> locals = {
+    {"float", 1},
+    {"vec2",  2},
+    {"vec3",  3},
+    {"vec4",  4},
+};
+
+Q_DECLARE_METATYPE(Vector2)
+Q_DECLARE_METATYPE(Vector3)
+Q_DECLARE_METATYPE(Vector4)
+
+class ModuleObserver : public Object {
+    A_REGISTER(ModuleObserver, Object, Editor)
+
+    A_METHODS(
+        A_SLOT(ModuleObserver::onModuleEnabled)
+    )
+
+public:
+    ModuleObserver() :
+            m_module(nullptr) {
+
+    }
+
+    void setEffectModule(EffectModule *module) {
+        m_module = module;
+    }
+
+private:
+    void onModuleEnabled(bool enabled) {
+        m_module->setEnabled(enabled);
+    }
+
+private:
+    EffectModule *m_module;
+
+};
+
+EffectModule::EffectModule() :
+        m_effect(nullptr),
+        m_stage(Spawn),
+        m_enabled(true),
+        m_checkBoxWidget(nullptr),
+        m_observer(new ModuleObserver) {
+
+    m_observer->setEffectModule(this);
+}
+
+Widget *EffectModule::widget(Object *parent) {
+    if(m_checkBoxWidget == nullptr) {
+        std::string moduleName = objectName().toStdString();
+
+        Actor *function = Engine::composeActor(gCheckBoxWidget, moduleName, parent);
+        m_checkBoxWidget = function->getComponent<CheckBox>();
+        RectTransform *checkBoxRect = m_checkBoxWidget->rectTransform();
+        checkBoxRect->setAnchors(Vector2(0.0f, 0.5f), Vector2(1.0f, 0.5f));
+        checkBoxRect->setSize(Vector2(200.0f, 20.0f));
+
+        bool res = Object::connect(m_checkBoxWidget, _SIGNAL(toggled(bool)), m_observer, _SLOT(onModuleEnabled(bool)));
+
+        m_checkBoxWidget->setChecked(m_enabled);
+        m_checkBoxWidget->setText(moduleName);
+        m_checkBoxWidget->setMirrored(true);
+    }
+
+    return m_checkBoxWidget;
+}
+
+void EffectModule::setEnabled(bool enabled) {
+    if(m_checkBoxWidget) {
+        m_checkBoxWidget->blockSignals(true);
+        m_checkBoxWidget->setChecked(enabled);
+        m_checkBoxWidget->blockSignals(false);
+    }
+
+    m_enabled = enabled;
+    emit updated();
+}
+
+bool EffectModule::event(QEvent *e) {
+    if(e->type() == QEvent::DynamicPropertyChange) {
+        QDynamicPropertyChangeEvent *ev = static_cast<QDynamicPropertyChangeEvent *>(e);
+        if(ev && !signalsBlocked()) {
+            QByteArray name(ev->propertyName());
+            QVariant value = property(name);
+
+            if(value.isValid()) {
+                QByteArrayList list = name.split('/');
+                name = list.last();
+
+                int modeIndex = name.indexOf(gMode);
+                if(modeIndex > -1) {
+                    name = name.mid(0, modeIndex);
+                    EffectModule::ParameterData *data = parameter(name.toStdString());
+                    if(data) {
+                        data->mode = value.value<SelectorData>();
+                    }
+
+                    setRoot(m_effect);
+                } else {
+                    QByteArray prop = list.front();
+                    prop = prop.mid(0, prop.indexOf(gMode));
+
+                    EffectModule::ParameterData *data = parameter(prop.toStdString());
+
+                    if(data) {
+                        if(name == gMax) {
+                            data->max = value;
+                        } else {
+                            data->min = value;
+                        }
+
+                        emit updated();
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    return QObject::event(e);
+}
+
+void EffectModule::load(const std::string &path) {
+    QFile file(path.c_str());
+    if(file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        QDomDocument doc;
+        if(doc.setContent(&file)) {
+            QDomElement function = doc.documentElement();
+
+            QString moduleName = QFileInfo(function.attribute(gName)).baseName();
+            setObjectName(moduleName);
+
+            static const QMap<QString, Stage> stages = {
+                {"spawn", Stage::Spawn},
+                {"update", Stage::Update},
+                {"render", Stage::Render}
+            };
+            m_stage = stages.value(function.attribute("stage").toLower(), Stage::Spawn);
+
+            QDomNode n = function.firstChild();
+            while(!n.isNull()) {
+                QDomElement element = n.toElement();
+
+                if(element.tagName() == "options") {
+                    std::string name = element.attribute(gName).toStdString();
+                    std::vector<std::string> values;
+
+                    QDomNode optionNode = element.firstChild();
+                    while(!optionNode.isNull()) {
+                        QDomElement optionElement = optionNode.toElement();
+                        values.push_back(optionElement.attribute(gValue).toStdString());
+
+                        optionNode = optionNode.nextSibling();
+                    }
+
+                    m_options[name] = values;
+                } else if(element.tagName() == "params") { // parse inputs
+                    QDomNode paramNode = element.firstChild();
+                    while(!paramNode.isNull()) {
+                        QDomElement paramElement = paramNode.toElement();
+
+                        ParameterData data;
+
+                        data.name = paramElement.attribute(gName).toStdString();
+                        data.mode.type = paramElement.attribute("mode");
+                        data.mode.current = paramElement.attribute("defaultMode");
+                        data.max = data.min = EffectRootNode::toVariant(paramElement.attribute("default"), paramElement.attribute(gType));
+                        QString visible = paramElement.attribute("visible");
+                        if(!visible.isEmpty()) {
+                            data.visible = visible == "true";
+                        }
+
+                        addParameter(data);
+
+                        paramNode = paramNode.nextSibling();
+                    }
+                } else if(element.tagName() == "operations") {
+                    QDomNode operationNode = element.firstChild();
+                    while(!operationNode.isNull()) {
+                        QDomElement operationElement = operationNode.toElement();
+
+                        static const QMap<QString, Operation> operations = {
+                            {"set", Operation::Set},
+                            {"add", Operation::Add},
+                            {"sub", Operation::Subtract},
+                            {"mul", Operation::Multiply},
+                            {"div", Operation::Divide},
+                        };
+
+                        OperationData data;
+                        data.operation = operations.value(operationElement.attribute("code").toLower(), Operation::Set);
+                        data.result = operationElement.attribute("result").toStdString();
+                        data.args.push_back(operationElement.attribute("arg0").toStdString());
+                        data.args.push_back(operationElement.attribute("arg1").toStdString());
+
+                        addOperation(data);
+
+                        operationNode = operationNode.nextSibling();
+                    }
+                }else if(element.tagName() == "bindings") {
+                    QDomNode bindNode = element.firstChild();
+                    while(!bindNode.isNull()) {
+                        QDomElement bindElement = bindNode.toElement();
+
+                        int size = 1;
+                        auto it = locals.find(bindElement.attribute(gType).toStdString());
+                        if(it != locals.end()) {
+                            size = it->second;
+                        }
+
+                        m_effect->addAttribute(bindElement.attribute(gName).toStdString(),
+                                               size,
+                                               bindElement.attribute("offset").toInt());
+
+                        bindNode = bindNode.nextSibling();
+                    }
+                }
+
+                n = n.nextSibling();
+            }
+
+            setRoot(m_effect);
+        }
+    }
+}
+
+void EffectModule::fromXml(const QDomElement &element) {
+    QDomElement valueElement = element.firstChildElement(gValue);
+    while(!valueElement.isNull()) {
+        QString type = valueElement.attribute(gType);
+        QString name = valueElement.attribute(gName);
+        QString value = valueElement.text();
+
+        QVariant variant = EffectRootNode::toVariant(valueElement.text(), type);
+        auto it = m_options.find(type.toStdString());
+        if(it != m_options.end()) {
+            SelectorData data;
+            data.current = value;
+            data.type = type;
+            for(auto option : it->second) {
+                data.values << option.c_str();
+            }
+            variant = QVariant::fromValue(data);
+        }
+
+        setProperty(qPrintable(name), variant);
+
+        valueElement = valueElement.nextSiblingElement();
+    }
+}
+
+Vector4 toVector(const QVariant &variant) {
+    Vector4 result;
+
+    if(variant.canConvert<Vector2>()) {
+        result = variant.value<Vector2>();
+    } else if(variant.canConvert<Vector3>()) {
+        result = variant.value<Vector3>();
+    } else if(variant.canConvert<Vector4>()) {
+        result = variant.value<Vector4>();
+    } else if(variant.userType() == QMetaType::QColor) {
+        QColor col = variant.value<QColor>();
+        result = Vector4(col.redF(), col.greenF(), col.blueF(), col.alphaF());
+    } else {
+        result.x = variant.toFloat();
+    }
+
+    return result;
+}
+
+VariantList EffectModule::saveData() const {
+    VariantList operations;
+    for(auto it : m_operations) {
+        VariantList data;
+        data.push_back(it.operation);
+
+        int32_t returnSpace = Particle;
+
+        int32_t returnOffset = 0;
+        int32_t returnSize = 0;
+
+        auto regIt = locals.find(it.result);
+        if(regIt != locals.end()) {
+             returnSize = regIt->second;
+             returnSpace = Local;
+        } else {
+            returnSpace = EffectRootNode::getSpace(it.result);
+            returnOffset = m_effect->attributeOffset(it.result);
+            returnSize = m_effect->attributeSize(it.result);
+        }
+
+        VariantList arguments;
+
+        for(int arg = 0; arg < it.args.size(); arg++) {
+            VariantList argument;
+
+            std::string argName = it.args.at(arg);
+
+            int32_t argSpace = EffectRootNode::getSpace(argName);
+            int32_t argOffset = m_effect->attributeOffset(argName);
+            int32_t argSize = m_effect->attributeSize(argName);
+
+            Vector4 min;
+            Vector4 max;
+
+            auto regIt = locals.find(argName);
+            if(regIt != locals.end()) {
+                argSpace = Local;
+                argOffset = 0;
+                argSize = regIt->second;
+            } else if(argOffset == -1 && !argName.empty()) {
+                const ParameterData *attribute = parameterConst(argName);
+                if(attribute) {
+                    min = toVector(attribute->min);
+                    max = toVector(attribute->max);
+
+                    argSize = EffectRootNode::typeSize(attribute->min);
+
+                    if(attribute->mode.current.toLower() == gRandom) {
+                        argSpace = Space::Random;
+                    } else {
+                        argSpace = Space::Constant;
+                    }
+                } else {
+                    QVariant v = EffectRootNode::toVariant(argName.c_str(), "auto");
+                    min = max = toVector(v);
+
+                    argSize = EffectRootNode::typeSize(v);
+                    argSpace = Space::Constant;
+                }
+            }
+
+            argument.push_back(argSpace);
+
+            switch(argSpace) {
+                case Constant: {
+                    argument.push_back(argSize);
+                    for(int i = 0; i < argSize; i++) {
+                        argument.push_back(min[i]);
+                    }
+                } break;
+                case Random: {
+                    argument.push_back(argSize);
+                    for(int i = 0; i < argSize; i++) {
+                        argument.push_back(min[i]);
+                    }
+
+                    for(int i = 0; i < argSize; i++) {
+                        argument.push_back(max[i]);
+                    }
+                } break;
+                default: {
+                    argument.push_back(argSize);
+                    argument.push_back(argOffset);
+                } break;
+            }
+
+
+            arguments.push_back(argument);
+       }
+
+        data.push_back(returnSpace);
+        data.push_back(returnOffset);
+        data.push_back(returnSize);
+
+        data.push_back(arguments);
+
+        operations.push_back(data);
+    }
+
+    return operations;
+}
+
+void EffectModule::addParameter(const ParameterData &data) {
+    m_parameters.push_back(data);
+}
+
+void EffectModule::addOperation(const OperationData &data) {
+    m_operations.push_back(data);
+}
+
+void EffectModule::setRoot(EffectRootNode *effect) {
+    m_effect = effect;
+
+    blockSignals(true);
+    for(auto it : dynamicPropertyNames()) {
+        setProperty(it, QVariant());
+    }
+
+    for(auto &it : m_parameters) {
+        if(!it.visible) {
+            continue;
+        }
+
+        if(!it.mode.type.isEmpty()) {
+            if(it.mode.values.empty()) {
+                std::string type = it.mode.type.toStdString();
+                auto optIt = m_options.find(type);
+                for(auto opt : optIt->second) {
+                    it.mode.values << opt.c_str();
+                }
+            }
+
+            if(it.mode.current.isEmpty()) {
+                it.mode.current = it.mode.values.front();
+            }
+
+            std::string type = it.name + gMode;
+            setProperty(type.c_str(), QVariant::fromValue(it.mode));
+
+            if(it.mode.current.toLower() == gRandom) {
+                std::string minName = type + "/" + gMin;
+                std::string maxName = type + "/" + gMax;
+
+                setProperty(minName.c_str(), it.min);
+                setProperty(maxName.c_str(), it.max);
+            } else {
+                std::string name = type + "/" + gValue;
+
+                setProperty(name.c_str(), it.min);
+            }
+        } else {
+            setProperty(it.name.c_str(), it.min);
+        }
+    }
+    blockSignals(false);
+
+    emit moduleChanged();
+}
+
+EffectModule::ParameterData *EffectModule::parameter(const std::string &name) {
+    for(auto &it : m_parameters) {
+        if(it.name == name) {
+            return &it;
+        }
+    }
+    return nullptr;
+}
+
+const EffectModule::ParameterData *EffectModule::parameterConst(const std::string &name) const {
+    for(auto &it : m_parameters) {
+        if(it.name == name) {
+            return &it;
+        }
+    }
+    return nullptr;
+}
diff --git a/modules/editor/particletools/converter/effectmodule.h b/modules/editor/particletools/converter/effectmodule.h
new file mode 100644
index 000000000..5fce2b65d
--- /dev/null
+++ b/modules/editor/particletools/converter/effectmodule.h
@@ -0,0 +1,125 @@
+#ifndef EFFECTMODULE_H
+#define EFFECTMODULE_H
+
+#include <QObject>
+#include <QVariant>
+
+#include <resources/visualeffect.h>
+
+#include "SelectorEdit.h"
+
+class Widget;
+class CheckBox;
+
+class ModuleObserver;
+class EffectRootNode;
+
+class QDomElement;
+
+class EffectModule : public QObject {
+    Q_OBJECT
+    Q_CLASSINFO("Group", "Modificator")
+
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY updated DESIGNABLE true USER true)
+
+public:
+    enum Stage {
+        Spawn,
+        Update,
+        Render
+    };
+    Q_ENUM(Stage);
+
+    enum Operation {
+        Set = 0,
+        Add,
+        Subtract,
+        Multiply,
+        Divide
+    };
+    Q_ENUM(Operation)
+
+    enum Space {
+        System,
+        Emitter,
+        Particle,
+        Renderable,
+        Local,
+        Constant,
+        Random
+    };
+    Q_ENUM(Space)
+
+    struct ParameterData {
+        std::string name;
+
+        SelectorData mode;
+
+        QVariant min;
+        QVariant max;
+
+        bool visible = true;
+    };
+
+    struct OperationData {
+        Operation operation;
+
+        std::string result;
+
+        std::vector<std::string> args;
+    };
+
+public:
+    Q_INVOKABLE EffectModule();
+
+    bool enabled() const { return m_enabled; }
+    void setEnabled(bool enabled);
+
+    Stage stage() const { return m_stage; }
+    void setStage(Stage stage) { m_stage = stage; }
+
+    void setRoot(EffectRootNode *effect);
+
+    Widget *widget(Object *parent);
+
+    void load(const std::string &path);
+    void fromXml(const QDomElement &element);
+
+    VariantList saveData() const;
+
+    void addParameter(const ParameterData &data);
+    void addOperation(const OperationData &data);
+
+    ParameterData *parameter(const std::string &name);
+
+signals:
+    void updated();
+
+    void moduleChanged();
+
+protected:
+    bool event(QEvent *e) override;
+
+    const ParameterData *parameterConst(const std::string &name) const;
+
+protected:
+    std::vector<ParameterData> m_parameters;
+
+    std::vector<OperationData> m_operations;
+
+    std::map<std::string, std::vector<std::string>> m_options;
+
+    EffectRootNode *m_effect;
+
+    Stage m_stage;
+
+    bool m_enabled;
+
+protected:
+    CheckBox *m_checkBoxWidget;
+
+    ModuleObserver *m_observer;
+
+};
+
+#endif // EFFECTMODULE_H
diff --git a/modules/editor/particletools/converter/effectrootnode.cpp b/modules/editor/particletools/converter/effectrootnode.cpp
new file mode 100644
index 000000000..33dfc9584
--- /dev/null
+++ b/modules/editor/particletools/converter/effectrootnode.cpp
@@ -0,0 +1,408 @@
+#include "effectrootnode.h"
+
+#include <QMetaProperty>
+
+#include <engine.h>
+
+#include <components/frame.h>
+#include <components/label.h>
+#include <components/image.h>
+#include <components/button.h>
+#include <components/layout.h>
+#include <components/checkbox.h>
+#include <components/recttransform.h>
+
+#include <components/foldout.h>
+
+#include "effectgraph.h"
+#include "effectmodule.h"
+
+#include "SelectorEdit.h"
+
+Q_DECLARE_METATYPE(Vector2)
+Q_DECLARE_METATYPE(Vector3)
+Q_DECLARE_METATYPE(Vector4)
+
+namespace {
+    const char *gModules("modules");
+    const char *gModule("module");
+    const char *gType("type");
+    const char *gName("name");
+    const char *gValue("value");
+}
+
+EffectRootNode::EffectRootNode() :
+        m_spawnFold(nullptr),
+        m_updateFold(nullptr),
+        m_renderFold(nullptr),
+        m_spawnRate(1.0f),
+        m_capacity(32),
+        m_gpu(false),
+        m_local(false),
+        m_continuous(true) {
+
+    setTypeName("EffectRootNode");
+
+    addAttribute("e.age", 1, 0);
+    addAttribute("e.deltaTime", 1, 1);
+    addAttribute("e.spawnCounter", 1, 2);
+
+    addAttribute("p.age", 1, 0);
+    addAttribute("p.lifetime", 1, 1);
+    addAttribute("p.position", 3, 2);
+    addAttribute("p.rotation", 3, 5);
+    addAttribute("p.size", 3, 8);
+    addAttribute("p.color", 4, 11);
+    addAttribute("p.velocity", 3, 15);
+}
+
+EffectRootNode::~EffectRootNode() {
+    removeAllModules();
+}
+
+Vector4 EffectRootNode::color() const {
+    return Vector4(0.141f, 0.384f, 0.514f, 1.0f);
+}
+
+QDomElement EffectRootNode::toXml(QDomDocument &xml) {
+    QDomElement result = GraphNode::toXml(xml);
+
+    QDomElement modulesElement = xml.createElement(gModules);
+    for(auto it : m_modules) {
+        const QMetaObject *meta = it->metaObject();
+
+        QDomElement moduleElement = xml.createElement(gModule);
+        moduleElement.setAttribute(gType, it->objectName());
+
+        for(int i = 0; i < meta->propertyCount(); i++) {
+            QMetaProperty property = meta->property(i);
+            if(property.isUser(this)) {
+                QDomElement valueElement = fromVariant(property.read(it), xml);
+                valueElement.setAttribute(gName, property.name());
+
+                moduleElement.appendChild(valueElement);
+            }
+        }
+
+        for(auto property : it->dynamicPropertyNames()) {
+            QVariant value = it->property(property);
+            if(value.canConvert<SelectorData>()) {
+                QDomElement valueElement = xml.createElement(gValue);
+
+                SelectorData select = value.value<SelectorData>();
+                valueElement.setAttribute(gName, qPrintable(property));
+                valueElement.setAttribute(gType, select.type);
+                valueElement.appendChild(xml.createTextNode(select.current));
+
+                moduleElement.appendChild(valueElement);
+            } else {
+                QDomElement valueElement = fromVariant(value, xml);
+
+                valueElement.setAttribute(gName, qPrintable(property));
+                moduleElement.appendChild(valueElement);
+            }
+        }
+
+        modulesElement.appendChild(moduleElement);
+    }
+    result.appendChild(modulesElement);
+
+    return result;
+}
+
+void EffectRootNode::fromXml(const QDomElement &element) {
+    GraphNode::fromXml(element);
+
+    EffectGraph *graph = static_cast<EffectGraph *>(m_graph);
+
+    QDomElement modulesElement = element.firstChildElement(gModules);
+    if(!modulesElement.isNull()) {
+        QDomElement moduleElement = modulesElement.firstChildElement(gModule);
+        while(!moduleElement.isNull()) {
+            QString modulePath = graph->modulePath(moduleElement.attribute(gType));
+
+            EffectModule *function = addModule(modulePath.toStdString());
+
+            if(function) {
+                function->fromXml(moduleElement);
+            }
+
+            moduleElement = moduleElement.nextSiblingElement();
+        }
+    }
+}
+
+Widget *EffectRootNode::widget() {
+    Widget *result = GraphNode::widget();
+
+    if(m_spawnFold == nullptr) {
+        Actor *spawnActor = Engine::composeActor("Foldout", "Spawn", result->actor());
+        m_spawnFold = spawnActor->getComponent<Foldout>();
+        m_spawnFold->setText("Particle Spawn");
+
+        RectTransform *spawnFoldRect = m_spawnFold->rectTransform();
+        spawnFoldRect->setAnchors(Vector2(0.0f, 0.5f), Vector2(1.0f, 0.5f));
+
+        Actor *updateActor = Engine::composeActor("Foldout", "Update", result->actor());
+        m_updateFold = updateActor->getComponent<Foldout>();
+        m_updateFold->setText("Particle Update");
+
+        RectTransform *updateFoldRect = m_updateFold->rectTransform();
+        updateFoldRect->setAnchors(Vector2(0.0f, 0.5f), Vector2(1.0f, 0.5f));
+
+        Actor *renderActor = Engine::composeActor("Foldout", "Render", result->actor());
+        m_renderFold = renderActor->getComponent<Foldout>();
+        m_renderFold->setText("Render");
+
+        RectTransform *renderFoldRect = m_renderFold->rectTransform();
+        renderFoldRect->setAnchors(Vector2(0.0f, 0.5f), Vector2(1.0f, 0.5f));
+
+        RectTransform *rect = result->rectTransform();
+        rect->setPadding(Vector4(0.0f, 0.0f, 10.0f, 0.0f));
+
+        Layout *layout = rect->layout();
+        layout->addTransform(spawnFoldRect);
+        layout->addTransform(updateFoldRect);
+        layout->addTransform(renderFoldRect);
+
+        for(auto it : m_modules) {
+            switch(it->stage()) {
+                case EffectModule::Spawn: {
+                    m_spawnFold->addWidget(it->widget(m_spawnFold->actor()));
+                } break;
+                case EffectModule::Update: {
+                    m_updateFold->addWidget(it->widget(m_updateFold->actor()));
+                } break;
+                case EffectModule::Render: {
+                    m_renderFold->addWidget(it->widget(m_renderFold->actor()));
+                } break;
+                default: break;
+            }
+        }
+    }
+
+    return result;
+}
+
+void EffectRootNode::addAttribute(const std::string &name, int size, int offset) {
+    for(auto it : m_attributes) {
+        if(it.name == name) {
+            return;
+        }
+    }
+
+    AttributeData data;
+    data.name = name;
+    data.size = size;
+    data.offset = offset;
+
+    m_attributes.push_back(data);
+}
+
+int EffectRootNode::attributeOffset(const std::string &name) {
+    std::string local = name;
+
+    int32_t offset = 0;
+    QByteArrayList list = QByteArray(name.c_str()).split('.');
+    if(list.size() > 1) {
+        local = (list.at(0) + "." + list.at(1)).toStdString();
+        if(list.size() == 3) {
+            static const QMap<char, uint8_t> maps = {
+                {'x', 0},
+                {'y', 1},
+                {'z', 2},
+                {'w', 3},
+                {'r', 0},
+                {'g', 1},
+                {'b', 2},
+                {'a', 3}
+            };
+
+            offset = maps.value(list.back().at(0), 0);
+        }
+    }
+
+    for(auto it : m_attributes) {
+        if(it.name == local) {
+            return it.offset + offset;
+        }
+    }
+
+    return -1;
+}
+
+int EffectRootNode::attributeSize(const std::string &name) {
+    std::string local = name;
+
+    int32_t size = 0;
+    QByteArrayList list = QByteArray(name.c_str()).split('.');
+    if(list.size() > 1) {
+        local = (list.at(0) + "." + list.at(1)).toStdString();
+        if(list.size() == 3) {
+            size = list.back().size();
+        }
+    }
+
+    for(auto it : m_attributes) {
+        if(it.name == local) {
+            return (size > 0) ? MIN(size, it.size) : it.size;
+        }
+    }
+
+    return 0;
+}
+
+int EffectRootNode::getSpace(const std::string &name) {
+    static const QMap<char, EffectModule::Space> spaces {
+        {'s', EffectModule::System},
+        {'e', EffectModule::Emitter},
+        {'p', EffectModule::Particle},
+        {'r', EffectModule::Renderable}
+    };
+
+    QByteArrayList list = QByteArray(name.c_str()).split('.');
+    if(list.size() > 1) {
+        return spaces.value(list.front().at(0), EffectModule::Particle);
+    }
+
+    return -1;
+}
+
+VariantList EffectRootNode::saveData() const {
+    VariantList result;
+
+    std::string meshPath;
+    std::string materialPath;
+
+    for(auto it : m_modules) {
+        if(it->enabled() && it->stage() == EffectModule::Stage::Render) {
+            EffectModule::ParameterData *data = it->parameter("material");
+            if(data) {
+                materialPath = data->min.value<Template>().path.toStdString();
+            }
+
+            data = it->parameter("mesh");
+            if(data) {
+                meshPath = data->min.value<Template>().path.toStdString();
+            }
+        }
+    }
+
+    result.push_back(meshPath);
+    result.push_back(materialPath);
+
+    result.push_back(isGpu());
+    result.push_back(isLocal());
+    result.push_back(isContinuous());
+
+    result.push_back(capacity());
+    result.push_back(spawnRate());
+
+    int particleStride = 0;
+    for(auto it : m_attributes) {
+        if(getSpace(it.name) == EffectModule::Particle) {
+            particleStride += it.size;
+        }
+    }
+
+    result.push_back(particleStride);
+
+    VariantList spawnOperations;
+    VariantList updateOperations;
+    VariantList renderOperations;
+
+    for(const auto module : m_modules) {
+        if(!module->enabled()) {
+            continue;
+        }
+
+        VariantList data = module->saveData();
+
+        switch(module->stage()) {
+            case EffectModule::Spawn: {
+                spawnOperations.insert(spawnOperations.end(), data.begin(), data.end());
+            } break;
+            case EffectModule::Update: {
+                updateOperations.insert(updateOperations.end(), data.begin(), data.end());
+            } break;
+            case EffectModule::Render: {
+                renderOperations.insert(renderOperations.end(), data.begin(), data.end());
+            } break;
+            default: break;
+        }
+    }
+
+    result.push_back(spawnOperations);
+    result.push_back(updateOperations);
+    result.push_back(renderOperations);
+
+    return result;
+}
+
+void EffectRootNode::onShowMenu() const {
+    EffectGraph *graph = static_cast<EffectGraph *>(m_graph);
+    graph->showFunctionsMenu();
+}
+
+EffectModule *EffectRootNode::addModule(const std::string &path) {
+    EffectModule *module = new EffectModule;
+
+    module->setParent(this);
+    module->setRoot(this);
+
+    module->load(path);
+
+    connect(module, &EffectModule::updated, static_cast<EffectGraph *>(m_graph), &EffectGraph::effectUpdated);
+    connect(module, &EffectModule::moduleChanged, static_cast<EffectGraph *>(m_graph), &EffectGraph::moduleChanged);
+
+    m_modules.push_back(module);
+
+    if(m_nodeWidget) {
+        Widget *widget = module->widget(m_nodeWidget->actor());
+
+        switch(module->stage()) {
+            case EffectModule::Spawn: {
+                m_spawnFold->addWidget(widget);
+            } break;
+            case EffectModule::Update: {
+                m_updateFold->addWidget(widget);
+            } break;
+            case EffectModule::Render: {
+                m_renderFold->addWidget(widget);
+            } break;
+            default: break;
+        }
+    }
+
+    return module;
+}
+
+void EffectRootNode::removeModule(EffectModule *function) {
+    m_modules.remove(function);
+
+    Widget *widget = function->widget(nullptr);
+    delete widget->actor();
+
+    delete function;
+}
+
+void EffectRootNode::removeAllModules() {
+    for(auto it : m_modules) {
+        Widget *widget = it->widget(nullptr);
+        delete widget->actor();
+
+        delete it;
+    }
+    m_modules.clear();
+}
+
+int EffectRootNode::typeSize(const QVariant &value) {
+    if(value.canConvert<Vector2>()) {
+        return 2;
+    } else if(value.canConvert<Vector3>()) {
+        return 3;
+    } else if(value.canConvert<Vector4>() || value.canConvert<QColor>()) {
+        return 4;
+    }
+    return 1;
+}
diff --git a/modules/editor/particletools/converter/effectrootnode.h b/modules/editor/particletools/converter/effectrootnode.h
new file mode 100644
index 000000000..53bc4c48f
--- /dev/null
+++ b/modules/editor/particletools/converter/effectrootnode.h
@@ -0,0 +1,95 @@
+#ifndef EFFECTROOTNODE_H
+#define EFFECTROOTNODE_H
+
+#include <resources/material.h>
+#include <resources/mesh.h>
+
+#include <editor/graph/graphnode.h>
+#include <editor/projectsettings.h>
+
+class Foldout;
+class EffectModule;
+
+class EffectRootNode : public GraphNode {
+    Q_OBJECT
+
+    Q_PROPERTY(bool local READ isLocal WRITE setLocal NOTIFY updated DESIGNABLE true USER true)
+    Q_PROPERTY(bool continuous READ isContinuous WRITE setContinuous NOTIFY updated DESIGNABLE true USER true)
+    Q_PROPERTY(float spawnRate READ spawnRate WRITE setSpawnRate NOTIFY updated DESIGNABLE true USER true)
+    Q_PROPERTY(int capacity READ capacity WRITE setCapacity NOTIFY updated DESIGNABLE true USER true)
+
+public:
+    EffectRootNode();
+    ~EffectRootNode();
+
+    bool isGpu() const { return m_gpu; }
+    void setGpu(bool value) { m_gpu = value; emit updated(); }
+
+    bool isLocal() const { return m_local; }
+    void setLocal(bool value) { m_local = value; emit updated(); }
+
+    bool isContinuous() const { return m_continuous; }
+    void setContinuous(bool value) { m_local = value; emit updated(); }
+
+    float spawnRate() const { return m_spawnRate; }
+    void setSpawnRate(float value) { m_spawnRate = value; emit updated(); }
+
+    int capacity() const { return m_capacity; }
+    void setCapacity(int value) { m_capacity = value; emit updated(); }
+
+    EffectModule *addModule(const std::string &path);
+
+    void removeModule(EffectModule *function);
+    void removeAllModules();
+
+    static int getSpace(const std::string &name);
+
+    void addAttribute(const std::string &name, int size, int offset = -1);
+
+    int attributeOffset(const std::string &name);
+    int attributeSize(const std::string &name);
+
+    VariantList saveData() const;
+
+    static int typeSize(const QVariant &value);
+
+public slots:
+    void onShowMenu() const;
+
+private:
+    Vector4 color() const override;
+
+    QDomElement toXml(QDomDocument &xml) override;
+    void fromXml(const QDomElement &element) override;
+
+    Widget *widget() override;
+
+    bool isRemovable() const override { return false; }
+
+private:
+    std::list<EffectModule *> m_modules;
+
+    struct AttributeData {
+        std::string name;
+
+        int32_t size;
+
+        int32_t offset;
+    };
+
+    std::list<AttributeData> m_attributes;
+
+    Foldout *m_spawnFold;
+    Foldout *m_updateFold;
+    Foldout *m_renderFold;
+
+    float m_spawnRate;
+
+    int m_capacity;
+
+    bool m_gpu;
+    bool m_local;
+    bool m_continuous;
+};
+
+#endif // EFFECTROOTNODE_H
diff --git a/modules/editor/particletools/editor/icons/remove.png b/modules/editor/particletools/editor/icons/remove.png
new file mode 100644
index 000000000..8c5e0e08b
Binary files /dev/null and b/modules/editor/particletools/editor/icons/remove.png differ
diff --git a/modules/editor/particletools/editor/icons/stars.png b/modules/editor/particletools/editor/icons/stars.png
new file mode 100644
index 000000000..7b8d70f85
Binary files /dev/null and b/modules/editor/particletools/editor/icons/stars.png differ
diff --git a/modules/editor/particletools/editor/particleedit.cpp b/modules/editor/particletools/editor/particleedit.cpp
index 56714e1e6..167502b2e 100644
--- a/modules/editor/particletools/editor/particleedit.cpp
+++ b/modules/editor/particletools/editor/particleedit.cpp
@@ -1,12 +1,8 @@
 #include "particleedit.h"
 #include "ui_particleedit.h"
 
-#include <QQmlContext>
-#include <QQuickItem>
-#include <QQmlEngine>
-#include <QMessageBox>
-
-#include "../converter/effectconverter.h"
+#include <QSettings>
+#include <QToolButton>
 
 #include <global.h>
 
@@ -15,170 +11,159 @@
 #include <components/world.h>
 #include <components/scene.h>
 #include <components/actor.h>
-#include <components/particlerender.h>
+#include <components/effectrender.h>
 #include <components/camera.h>
 
+#include "effectbuilder.h"
+#include "effectrootnode.h"
+#include "effectmodule.h"
+
+namespace {
+    const char *gFunction("function");
+}
+
 ParticleEdit::ParticleEdit() :
-        m_modified(false),
         ui(new Ui::ParticleEdit),
+        m_builder(new EffectBuilder),
+        m_controller(new CameraController()),
         m_effect(nullptr),
-        m_builder(new EffectConverter),
-        m_controller(nullptr),
         m_render(nullptr),
-        m_selectedItem(nullptr) {
+        m_lastCommand(nullptr) {
 
     ui->setupUi(this);
 
-    m_controller = new CameraController();
     m_controller->blockMovement(true);
     m_controller->setFree(false);
 
-    World *graph = Engine::objectCreate<World>("World");
-    Scene *scene = Engine::objectCreate<Scene>("Scene", graph);
+    World *world = Engine::objectCreate<World>("World");
+    Scene *scene = Engine::objectCreate<Scene>("Scene", world);
 
     ui->preview->setController(m_controller);
-    ui->preview->setWorld(graph);
+    ui->preview->setWorld(world);
     ui->preview->init(); // must be called after all options set
 
-    m_effect = Engine::composeActor("ParticleRender", "ParticleEffect", scene);
-    m_render = static_cast<ParticleRender *>(m_effect->component("ParticleRender"));
+    m_effect = Engine::composeActor("EffectRender", "ParticleEffect", scene);
+    m_render = m_effect->getComponent<EffectRender>();
 
-    startTimer(16);
+    connect(ui->graph, &GraphView::itemsSelected, this, &ParticleEdit::itemsSelected);
+    connect(m_builder, &EffectBuilder::effectUpdated, this, &ParticleEdit::onUpdateTemplate);
 
-    connect(m_builder, SIGNAL(effectUpdated()), this, SLOT(onUpdateTemplate()));
+    EffectGraph *graph = &m_builder->graph();
 
-    ui->quickWidget->rootContext()->setContextProperty("effectModel", QVariant::fromValue(m_builder->children()));
-    ui->quickWidget->setSource(QUrl("qrc:/qml/Emitters.qml"));
+    ui->graph->setWorld(Engine::objectCreate<World>("World"));
+    ui->graph->setGraph(graph);
+    ui->graph->init();
 
-    QQuickItem *item = ui->quickWidget->rootObject();
-    connect(item, SIGNAL(emitterSelected(QString)), this, SLOT(onEmitterSelected(QString)));
-    connect(item, SIGNAL(emitterCreate()), this, SLOT(onEmitterCreated()));
-    connect(item, SIGNAL(emitterDelete(QString)), this, SLOT(onEmitterDeleted(QString)));
+    connect(graph, &EffectGraph::moduleChanged, ui->graph, &GraphView::reselect);
 
-    connect(item, SIGNAL(functionSelected(QString,QString)), this, SLOT(onFunctionSelected(QString,QString)));
-    connect(item, SIGNAL(functionCreate(QString,QString)), this, SLOT(onFunctionCreated(QString,QString)));
-    connect(item, SIGNAL(functionDelete(QString,QString)), this, SLOT(onFunctionDeleted(QString,QString)));
+    startTimer(16);
+
+    readSettings();
 }
 
 ParticleEdit::~ParticleEdit() {
+    writeSettings();
+
     delete ui;
 
     delete m_effect;
 }
 
 void ParticleEdit::timerEvent(QTimerEvent *) {
-    if(m_render && isVisible()) {
+    if(m_render && ui->preview->isVisible()) {
         Camera::setCurrent(m_controller->camera());
         m_render->deltaUpdate(1.0f / 60.0f);
         Camera::setCurrent(nullptr);
     }
 }
 
+void ParticleEdit::readSettings() {
+    QSettings settings(COMPANY_NAME, EDITOR_NAME);
+    QVariant value = settings.value("effects.geometry");
+    if(value.isValid()) {
+        ui->splitter->restoreState(value.toByteArray());
+    }
+}
+
+void ParticleEdit::writeSettings() {
+    QSettings settings(COMPANY_NAME, EDITOR_NAME);
+    settings.setValue("effects.geometry", ui->splitter->saveState());
+}
+
 bool ParticleEdit::isModified() const {
-    return m_modified;
+    return (UndoManager::instance()->lastCommand(&m_builder->graph()) != m_lastCommand);
 }
 
 QStringList ParticleEdit::suffixes() const {
-    return static_cast<AssetConverter *>(m_builder)->suffixes();
+    return m_builder->suffixes();
 }
 
 void ParticleEdit::onActivated() {
-    if(m_selectedItem) {
-        emit itemsSelected({m_selectedItem});
-    }
+    ui->graph->reselect();
 }
 
-void ParticleEdit::loadAsset(AssetConverterSettings *settings) {
-    if(!m_settings.contains(settings)) {
-        AssetEditor::loadAsset(settings);
+QList<QWidget *> ParticleEdit::createActionWidgets(QObject *object, QWidget *parent) const {
+    QList<QWidget *> result;
 
-        m_render->setEffect(Engine::loadResource<ParticleEffect>(qPrintable(settings->destination())));
-        m_builder->load(m_settings.first()->source());
+    QToolButton *button = new QToolButton(parent);
+    button->setProperty(gFunction, QVariant::fromValue(object));
+    button->setIconSize(QSize(12, 12));
 
-        onUpdateTemplate(false);
+    if(dynamic_cast<EffectModule *>(object)) {
+        button->setIcon(QIcon(":/icons/remove.png"));
+        connect(button, SIGNAL(clicked(bool)), this, SLOT(onDeleteModule()));
+    } else {
+        button->setIcon(QIcon(":/Style/styles/dark/icons/plus.png"));
+        connect(button, SIGNAL(clicked(bool)), &m_builder->graph(), SLOT(showFunctionsMenu()));
     }
-}
 
-void ParticleEdit::saveAsset(const QString &path) {
-    if(!path.isEmpty() || !m_settings.first()->source().isEmpty()) {
-        m_builder->save(path.isEmpty() ? m_settings.first()->source() : path);
-        m_modified = false;
-    }
-}
+    result.push_back(button);
 
-void ParticleEdit::onNodeSelected(void *node) {
-    m_selectedItem = static_cast<QObject *>(node);
-    emit itemsSelected({m_selectedItem});
+    return result;
 }
 
-void ParticleEdit::onNodeDeleted() {
-    onNodeSelected(nullptr);
-}
+void ParticleEdit::loadAsset(AssetConverterSettings *settings) {
+    if(!m_settings.contains(settings)) {
+        AssetEditor::loadAsset(settings);
 
-void ParticleEdit::onEmitterSelected(QString emitter) {
-    EffectEmitter *obj = m_builder->findChild<EffectEmitter *>(emitter);
-    if(obj) {
-        onNodeSelected(obj);
-    }
-}
+        m_render->setEffect(Engine::loadResource<VisualEffect>(qPrintable(settings->destination())));
+        m_builder->graph().load(settings->source());
 
-void ParticleEdit::onEmitterCreated() {
-    onNodeSelected(m_builder->createEmitter());
-}
+        ui->graph->selectNode(m_builder->graph().rootNode());
 
-void ParticleEdit::onEmitterDeleted(QString name) {
-    QMessageBox msgBox(this);
-    msgBox.setIcon(QMessageBox::Question);
-    msgBox.setText(tr("Do you want to delete emitter?"));
-    msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
-    msgBox.setDefaultButton(QMessageBox::Cancel);
-
-    int result = msgBox.exec();
-    if(result == QMessageBox::Yes) {
-        m_builder->deleteEmitter(name);
-        onNodeSelected(nullptr);
-    }
-}
+        m_lastCommand = UndoManager::instance()->lastCommand(&m_builder->graph());
 
-void ParticleEdit::onFunctionSelected(QString emitter, QString function) {
-    EffectEmitter *obj = m_builder->findChild<EffectEmitter *>(emitter);
-    if(obj) {
-        EffectFunction *func = obj->findChild<EffectFunction *>(function);
-        if(func) {
-            onNodeSelected(func);
-        }
+        onUpdateTemplate();
     }
 }
 
-void ParticleEdit::onFunctionCreated(QString emitter, QString function) {
-    EffectEmitter *obj = m_builder->findChild<EffectEmitter *>(emitter);
-    if(obj) {
-        EffectFunction *func = obj->findChild<EffectFunction *>(function);
-        if(func == nullptr) {
-            onNodeSelected(m_builder->createFunction(emitter, function));
-        } else {
-            QMessageBox msgBox(this);
-            msgBox.setText(tr("This type of modifier already assigned."));
-            msgBox.exec();
-        }
-    }
-}
+void ParticleEdit::saveAsset(const QString &path) {
+    if(!path.isEmpty() || !m_settings.first()->source().isEmpty()) {
+        m_builder->graph().save(path.isEmpty() ? m_settings.first()->source() : path);
 
-void ParticleEdit::onFunctionDeleted(QString emitter, QString function) {
-    m_builder->deleteFunction(emitter, function);
+        m_lastCommand = UndoManager::instance()->lastCommand(&m_builder->graph());
+    }
 }
 
-void ParticleEdit::onUpdateTemplate(bool update) {
-    ParticleEffect *effect = m_render->effect();
+void ParticleEdit::onUpdateTemplate() {
+    VisualEffect *effect = m_render->effect();
     if(effect) {
-        effect->loadUserData(m_builder->data().toMap());
+        effect->loadUserData(m_builder->graph().data());
         m_render->setEffect(effect);
+
+        emit updated();
     }
+}
 
-    QObjectList list = m_builder->children();
-    ui->quickWidget->rootContext()->setContextProperty("effectModel", QVariant::fromValue(list));
+void ParticleEdit::onDeleteModule() {
+    EffectModule *module = static_cast<EffectModule *>(sender()->property(gFunction).value<QObject *>());
+
+    EffectRootNode *root = static_cast<EffectRootNode *>(module->parent());
+    if(root) {
+        root->removeModule(module);
+    }
 
-    m_modified = update;
+    ui->graph->reselect();
 }
 
 void ParticleEdit::changeEvent(QEvent *event) {
diff --git a/modules/editor/particletools/editor/particleedit.h b/modules/editor/particletools/editor/particleedit.h
index af97dd5e3..c16eb08a8 100644
--- a/modules/editor/particletools/editor/particleedit.h
+++ b/modules/editor/particletools/editor/particleedit.h
@@ -6,12 +6,14 @@
 #include <editor/asseteditor.h>
 
 class Actor;
-class ParticleRender;
+class EffectRender;
 
-class EffectConverter;
+class EffectBuilder;
 
 class CameraController;
 
+class UndoCommand;
+
 namespace Ui {
     class ParticleEdit;
 }
@@ -24,22 +26,18 @@ class ParticleEdit : public AssetEditor {
     ~ParticleEdit();
 
 private slots:
-    void onUpdateTemplate(bool update = true);
-
-    void onNodeSelected(void *node);
-    void onNodeDeleted();
-
-    void onEmitterSelected(QString emitter);
-    void onEmitterCreated();
-    void onEmitterDeleted(QString name);
+    void onUpdateTemplate();
 
-    void onFunctionSelected(QString emitter, QString function);
-    void onFunctionCreated(QString emitter, QString function);
-    void onFunctionDeleted(QString emitter, QString function);
+    void onDeleteModule();
 
     void onActivated() override;
 
 private:
+    void readSettings();
+    void writeSettings();
+
+    QList<QWidget *> createActionWidgets(QObject *object, QWidget *parent) const override;
+
     void loadAsset(AssetConverterSettings *settings) override;
     void saveAsset(const QString &path) override;
 
@@ -50,19 +48,17 @@ private slots:
     void timerEvent(QTimerEvent *) override;
     void changeEvent(QEvent *event) override;
 
-    bool m_modified;
-
     Ui::ParticleEdit *ui;
 
-    Actor *m_effect;
-
-    EffectConverter *m_builder;
+    EffectBuilder *m_builder;
 
     CameraController *m_controller;
 
-    ParticleRender *m_render;
+    Actor *m_effect;
+    EffectRender *m_render;
+
+    const UndoCommand *m_lastCommand;
 
-    QObject *m_selectedItem;
 };
 
 #endif // PARTICLEEDIT_H
diff --git a/modules/editor/particletools/editor/particleedit.ui b/modules/editor/particletools/editor/particleedit.ui
index 9f699bf0f..cc3f5a6c8 100644
--- a/modules/editor/particletools/editor/particleedit.ui
+++ b/modules/editor/particletools/editor/particleedit.ui
@@ -11,7 +11,11 @@
    </rect>
   </property>
   <property name="windowTitle">
-   <string>Particle Editor</string>
+   <string>Effect Editor</string>
+  </property>
+  <property name="windowIcon">
+   <iconset resource="../particle.qrc">
+    <normaloff>:/icons/stars.png</normaloff>:/icons/stars.png</iconset>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
@@ -35,11 +39,7 @@
       <enum>Qt::Horizontal</enum>
      </property>
      <widget class="Viewport" name="preview" native="true"/>
-     <widget class="QQuickWidget" name="quickWidget">
-      <property name="resizeMode">
-       <enum>QQuickWidget::SizeRootObjectToView</enum>
-      </property>
-     </widget>
+     <widget class="GraphView" name="graph" native="true"/>
     </widget>
    </item>
   </layout>
@@ -116,17 +116,20 @@
  </widget>
  <customwidgets>
   <customwidget>
-   <class>QQuickWidget</class>
+   <class>Viewport</class>
    <extends>QWidget</extends>
-   <header location="global">QtQuickWidgets/QQuickWidget</header>
+   <header>editor/viewport/viewport.h</header>
+   <container>1</container>
   </customwidget>
   <customwidget>
-   <class>Viewport</class>
+   <class>GraphView</class>
    <extends>QWidget</extends>
-   <header>editor/viewport/viewport.h</header>
+   <header>editor/graph/graphview.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
- <resources/>
+ <resources>
+  <include location="../particle.qrc"/>
+ </resources>
  <connections/>
 </ui>
diff --git a/modules/editor/particletools/modules/addvelocity.vfm b/modules/editor/particletools/modules/addvelocity.vfm
new file mode 100644
index 000000000..9241049e6
--- /dev/null
+++ b/modules/editor/particletools/modules/addvelocity.vfm
@@ -0,0 +1,12 @@
+<module name="Spawn/AddVelocity" stage="spawn">
+    <options name="velocitySpeedMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <params>
+        <param name="velocitySpeed" type="vec3" default="0, 1, 0" mode="velocitySpeedMode"/>
+    </params>
+    <operations>
+        <operation code="add" result="p.velocity" arg0="p.velocity" arg1="velocitySpeed"/>
+    </operations>
+</module>
diff --git a/modules/editor/particletools/modules/colorscale.vfm b/modules/editor/particletools/modules/colorscale.vfm
new file mode 100644
index 000000000..4d6fd7817
--- /dev/null
+++ b/modules/editor/particletools/modules/colorscale.vfm
@@ -0,0 +1,13 @@
+<module name="Update/ColorScale" stage="update">
+    <options name="colorScaleMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <params>
+        <param name="colorScale" type="vec4" default="0, 0, 0, 0" mode="colorScaleMode"/>
+    </params>
+    <operations>
+        <operation code="mul" result="vec4" arg0="colorScale" arg1="e.deltaTime"/>
+        <operation code="add" result="p.color" arg0="p.color" arg1="vec4"/>
+    </operations>
+</module>
diff --git a/modules/editor/particletools/modules/initparticle.vfm b/modules/editor/particletools/modules/initparticle.vfm
new file mode 100644
index 000000000..285422381
--- /dev/null
+++ b/modules/editor/particletools/modules/initparticle.vfm
@@ -0,0 +1,38 @@
+<module name="Spawn/InitializeParticle" stage="spawn">
+    <options name="lifetimeMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <options name="positionMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <options name="colorMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <options name="rotationMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <options name="sizeMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <params>
+        <param name="lifetime" type="float" default="0" mode="lifetimeMode"/>
+        <param name="position" type="vec3" default="0, 0, 0" mode="positionMode"/>
+        <param name="color" type="color" default="255, 255, 255, 255" mode="colorMode"/>
+        <param name="rotation" type="vec3" default="0, 0, 0" mode="rotationMode"/>
+        <param name="size" type="vec3" default="1, 1, 1" mode="sizeMode"/>
+    </params>
+    <operations>
+        <operation code="set" result="p.lifetime" arg0="lifetime"/>
+        <operation code="set" result="p.age" arg0="p.lifetime"/>
+        <operation code="set" result="p.position" arg0="position"/>
+        <operation code="set" result="p.color" arg0="color"/>
+        <operation code="set" result="p.rotation" arg0="rotation"/>
+        <operation code="set" result="p.size" arg0="size"/>
+        <operation code="set" result="p.velocity" arg0="0, 0, 0"/>
+    </operations>
+</module>
diff --git a/modules/editor/particletools/modules/resolvevelocity.vfm b/modules/editor/particletools/modules/resolvevelocity.vfm
new file mode 100644
index 000000000..7fe91cf39
--- /dev/null
+++ b/modules/editor/particletools/modules/resolvevelocity.vfm
@@ -0,0 +1,7 @@
+<module name="Update/ResolveVelocity" stage="update">
+    <params/>
+    <operations>
+        <operation code="mul" result="vec3" arg0="p.velocity" arg1="e.deltaTime"/>
+        <operation code="add" result="p.position" arg0="p.position" arg1="vec3"/>
+    </operations>
+</module>
diff --git a/modules/editor/particletools/modules/rotationrate.vfm b/modules/editor/particletools/modules/rotationrate.vfm
new file mode 100644
index 000000000..c534b7d32
--- /dev/null
+++ b/modules/editor/particletools/modules/rotationrate.vfm
@@ -0,0 +1,13 @@
+<module name="Update/RotationRate" stage="update">
+    <options name="rotationRateMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <params>
+        <param name="rotationRate" type="vec3" default="0, 0, 0" mode="rotationRateMode"/>
+    </params>
+    <operations>
+        <operation code="mul" result="vec3" arg0="rotationRate" arg1="e.deltaTime"/>
+        <operation code="add" result="p.rotation" arg0="p.rotation" arg1="vec3"/>
+    </operations>
+</module>
diff --git a/modules/editor/particletools/modules/sizescale.vfm b/modules/editor/particletools/modules/sizescale.vfm
new file mode 100644
index 000000000..e9cd70d37
--- /dev/null
+++ b/modules/editor/particletools/modules/sizescale.vfm
@@ -0,0 +1,13 @@
+<module name="Update/SizeScale" stage="update">
+    <options name="sizeScaleMode">
+        <option value="Constant"/>
+        <option value="Random"/>
+    </options>
+    <params>
+        <param name="sizeScale" type="vec3" default="0, 0, 0" mode="sizeScaleMode"/>
+    </params>
+    <operations>
+        <operation code="mul" result="vec3" arg0="sizeScale" arg1="e.deltaTime"/>
+        <operation code="add" result="p.size" arg0="p.size" arg1="vec3"/>
+    </operations>
+</module>
diff --git a/modules/editor/particletools/modules/spriterender.vfm b/modules/editor/particletools/modules/spriterender.vfm
new file mode 100644
index 000000000..605ab5caa
--- /dev/null
+++ b/modules/editor/particletools/modules/spriterender.vfm
@@ -0,0 +1,20 @@
+<module name="Render/SpriteRender" stage="render">
+    <params>
+        <param name="material" type="template" default="{00000000-0401-0000-0000-000000000000}, Material"/>
+        <param name="mesh" type="template" default="{e394db15-d7a2-481c-8926-eb3bbcf0d21a}, Mesh" visible="false"/>
+    </params>
+    <bindings>
+        <bind name="r.size" type="vec2" offset="0"/>
+        <bind name="r.rotation" type="float" offset="2"/>
+        <bind name="r.position" type="vec3" offset="12"/>
+        <bind name="r.color" type="vec4" offset="16"/>
+    </bindings>
+    <operations>
+        <operation code="set" result="r.size" arg0="p.size.xy"/>
+        <operation code="mul" result="r.rotation" arg0="p.rotation.z" arg1="0.017453"/>
+        <operation code="set" result="r.uvOffset" arg0="0, 0"/>
+        <operation code="set" result="r.uvScale" arg0="1, 1"/>
+        <operation code="set" result="r.position" arg0="p.position"/>
+        <operation code="set" result="r.color" arg0="p.color"/>
+    </operations>
+</module>
diff --git a/modules/editor/particletools/modules/updatestate.vfm b/modules/editor/particletools/modules/updatestate.vfm
new file mode 100644
index 000000000..73cba0720
--- /dev/null
+++ b/modules/editor/particletools/modules/updatestate.vfm
@@ -0,0 +1,6 @@
+<module name="Update/UpdateState" stage="update">
+    <params/>
+    <operations>
+        <operation code="sub" result="p.age" arg0="p.age" arg1="e.deltaTime"/>
+    </operations>
+</module>
diff --git a/modules/editor/particletools/particle.qrc b/modules/editor/particletools/particle.qrc
index 0d85ede7e..f72cecd68 100644
--- a/modules/editor/particletools/particle.qrc
+++ b/modules/editor/particletools/particle.qrc
@@ -1,6 +1,16 @@
 <RCC>
     <qresource prefix="/">
-        <file>qml/Emitters.qml</file>
-		<file>templates/ParticleEffect.efx</file>
+        <file>templates/ParticleEffect.efx</file>
+        <file>templates/VisualEffect.vfx</file>
+        <file alias="icons/remove.png">editor/icons/remove.png</file>
+        <file alias="icons/stars.png">editor/icons/stars.png</file>
+        <file>modules/addvelocity.vfm</file>
+        <file>modules/initparticle.vfm</file>
+        <file>modules/updatestate.vfm</file>
+        <file>modules/resolvevelocity.vfm</file>
+        <file>modules/rotationrate.vfm</file>
+        <file>modules/sizescale.vfm</file>
+        <file>modules/colorscale.vfm</file>
+        <file>modules/spriterender.vfm</file>
     </qresource>
 </RCC>
diff --git a/modules/editor/particletools/particletools.cpp b/modules/editor/particletools/particletools.cpp
index 2f57dca32..4bed561a3 100644
--- a/modules/editor/particletools/particletools.cpp
+++ b/modules/editor/particletools/particletools.cpp
@@ -2,12 +2,15 @@
 
 #include <amath.h>
 #include <engine.h>
+#include <editor/propertyedit.h>
 
 #include <cstring>
 
-#include "converter/effectconverter.h"
+#include "converter/effectbuilder.h"
 #include "editor/particleedit.h"
 
+#include "property/SelectorEdit.h"
+
 static const char *meta = \
 "{"
 "   \"module\": \"ParticleTools\","
@@ -16,16 +19,29 @@ static const char *meta = \
 "   \"author\": \"Evgeniy Prikazchikov\","
 "   \"objects\": {"
 "       \"EffectConverter\": \"converter\","
+"       \"EffectBuilder\": \"converter\","
 "       \"ParticleEdit\": \"editor\""
 "   }"
 "}";
 
+PropertyEdit *createCustomEditor(int userType, QWidget *parent, const QString &name, QObject *object) {
+    PropertyEdit *result = nullptr;
+
+    if(userType == qMetaTypeId<SelectorData>()) {
+        result = new SelectorEdit(parent);
+    }
+
+    return result;
+}
+
 Module *moduleCreate(Engine *engine) {
     return new ParticleTools(engine);
 }
 
 ParticleTools::ParticleTools(Engine *engine) :
         Module(engine) {
+
+    PropertyEdit::registerEditorFactory(createCustomEditor);
 }
 
 const char *ParticleTools::metaInfo() const {
@@ -33,8 +49,8 @@ const char *ParticleTools::metaInfo() const {
 }
 
 void *ParticleTools::getObject(const char *name) {
-    if(strcmp(name, "EffectConverter") == 0) {
-        return new EffectConverter;
+    if(strcmp(name, "EffectBuilder") == 0) {
+        return new EffectBuilder;
     } else if(strcmp(name, "ParticleEdit") == 0) {
         return new ParticleEdit;
     }
diff --git a/modules/editor/particletools/particletools.qbs b/modules/editor/particletools/particletools.qbs
index 53c6d9eee..357c83a4c 100644
--- a/modules/editor/particletools/particletools.qbs
+++ b/modules/editor/particletools/particletools.qbs
@@ -4,23 +4,30 @@ Project {
     id: particletools
     property stringList srcFiles: [
         "*.cpp",
-        "converter/*.cpp",
+        "converter/**/*.cpp",
         "editor/**/*.cpp",
         "editor/**/*.ui",
+        "property/*.cpp",
+        "property/*.ui",
         "*.qrc",
         "*.h",
         "converter/**/*.h",
-        "editor/**/*.h"
+        "editor/**/*.h",
+        "property/*.h"
     ]
 
     property stringList incPaths: [
+        "converter",
+        "property",
         "../../../engine/includes",
         "../../../engine/includes/resources",
         "../../../engine/includes/components",
         "../../../engine/includes/editor",
         "../../../thirdparty/next/inc",
         "../../../thirdparty/next/inc/math",
-        "../../../thirdparty/next/inc/core"
+        "../../../thirdparty/next/inc/core",
+        "../../../modules/editor/grapheditor",
+        "../../../modules/uikit/includes"
     ]
 
     DynamicLibrary {
@@ -31,10 +38,16 @@ Project {
         Depends { name: "bundle" }
         Depends { name: "next-editor" }
         Depends { name: "engine-editor" }
-        Depends { name: "Qt"; submodules: ["core", "gui", "widgets", "quickwidgets"]; }
+        Depends { name: "graph-editor" }
+        Depends { name: "uikit-editor" }
+        Depends { name: "Qt"; submodules: ["core", "gui", "widgets", "xml"]; }
         bundle.isBundle: false
 
-        cpp.defines: ["SHARED_DEFINE"]
+        cpp.defines: {
+            var result  = particletools.defines
+            result.push("SHARED_DEFINE")
+            return result
+        }
         cpp.includePaths: particletools.incPaths
         cpp.cxxLanguageVersion: particletools.languageVersion
         cpp.cxxStandardLibrary: particletools.standardLibrary
diff --git a/modules/editor/particletools/property/SelectorEdit.cpp b/modules/editor/particletools/property/SelectorEdit.cpp
new file mode 100644
index 000000000..05aa2b52d
--- /dev/null
+++ b/modules/editor/particletools/property/SelectorEdit.cpp
@@ -0,0 +1,42 @@
+#include "SelectorEdit.h"
+#include "ui_SelectorEdit.h"
+
+SelectorEdit::SelectorEdit(QWidget *parent) :
+        PropertyEdit(parent),
+        ui(new Ui::SelectorEdit) {
+
+    ui->setupUi(this);
+
+    connect(ui->comboBox, SIGNAL(currentIndexChanged(const QString&)), this, SIGNAL(dataChanged()));
+}
+
+SelectorEdit::~SelectorEdit() {
+    delete ui;
+}
+
+QVariant SelectorEdit::data() const {
+    m_current.current = ui->comboBox->currentText();
+    return QVariant::fromValue(m_current);
+}
+
+void SelectorEdit::setData(const QVariant &data) {
+    SelectorData selector = data.value<SelectorData>();
+
+    if(m_current.values != selector.values) {
+        m_current = selector;
+        ui->comboBox->clear();
+        ui->comboBox->addItems(m_current.values);
+    }
+
+    if(m_current.current != selector.current) {
+        m_current.current = selector.current;
+    }
+
+    int index = ui->comboBox->findText(selector.current);
+
+    if(index > -1) {
+        ui->comboBox->blockSignals(true);
+        ui->comboBox->setCurrentIndex(index);
+        ui->comboBox->blockSignals(false);
+    }
+}
diff --git a/modules/editor/particletools/property/SelectorEdit.h b/modules/editor/particletools/property/SelectorEdit.h
new file mode 100644
index 000000000..796ad8794
--- /dev/null
+++ b/modules/editor/particletools/property/SelectorEdit.h
@@ -0,0 +1,35 @@
+#ifndef SELECTOREDIT_H
+#define SELECTOREDIT_H
+
+#include <editor/propertyedit.h>
+
+namespace Ui {
+    class SelectorEdit;
+}
+
+struct SelectorData {
+    QString current;
+
+    QString type;
+
+    QStringList values;
+};
+Q_DECLARE_METATYPE(SelectorData)
+
+class SelectorEdit : public PropertyEdit {
+    Q_OBJECT
+
+public:
+    explicit SelectorEdit(QWidget *parent = nullptr);
+    ~SelectorEdit();
+
+    QVariant data() const override;
+    void setData(const QVariant &data) override;
+
+private:
+    Ui::SelectorEdit *ui;
+
+    mutable SelectorData m_current;
+};
+
+#endif // SELECTOREDIT_H
diff --git a/modules/editor/particletools/property/SelectorEdit.ui b/modules/editor/particletools/property/SelectorEdit.ui
new file mode 100644
index 000000000..fcda88e70
--- /dev/null
+++ b/modules/editor/particletools/property/SelectorEdit.ui
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>SelectorEdit</class>
+ <widget class="PropertyEdit" name="SelectorEdit">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>22</height>
+   </rect>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout">
+   <property name="spacing">
+    <number>2</number>
+   </property>
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>1</number>
+   </property>
+   <property name="rightMargin">
+    <number>2</number>
+   </property>
+   <property name="bottomMargin">
+    <number>1</number>
+   </property>
+   <item>
+    <widget class="QComboBox" name="comboBox"/>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>PropertyEdit</class>
+   <extends>QWidget</extends>
+   <header>editor/propertyedit.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/modules/editor/particletools/qml/Emitters.qml b/modules/editor/particletools/qml/Emitters.qml
deleted file mode 100644
index d0597e67b..000000000
--- a/modules/editor/particletools/qml/Emitters.qml
+++ /dev/null
@@ -1,303 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.3
-import QtGraphicalEffects 1.0
-
-import "qrc:/QML/qml/."
-
-Rectangle {
-    id: rectangle
-
-    color: "#757575"
-
-    Theme {
-        id: theme
-    }
-
-    signal emitterSelected(string emitter)
-    signal emitterCreate()
-    signal emitterDelete(string emitter)
-
-    signal functionSelected(string emitter, string name)
-    signal functionCreate(string emitter, string name)
-    signal functionDelete(string emitter, string name)
-
-    ListView {
-        id: emittersList
-        anchors.fill: parent
-        anchors.margins: 3
-        spacing: 3
-        model: effectModel
-        orientation: ListView.Horizontal
-        delegate: emitterDelegate
-
-        footer: Component {
-            Item {
-                width: 64
-                anchors.top: parent.top
-                anchors.bottom: parent.bottom
-
-                Rectangle {
-                    id: addEmitter
-                    anchors.fill: parent
-                    anchors.leftMargin: 3
-                    radius: 3
-                    color: theme.emitterColor
-
-                    Text {
-                        id: nameLabel
-                        anchors.fill: parent
-                        text: "+"
-                        color: theme.textColor
-                        font.pointSize: theme.textSize * 2
-                        horizontalAlignment: Text.AlignHCenter
-                        verticalAlignment: Text.AlignVCenter
-                    }
-
-                    MouseArea {
-                        anchors.fill: parent
-                        hoverEnabled: true
-                        onEntered: addEmitter.color = theme.hoverColor
-                        onExited: addEmitter.color = theme.emitterColor
-                        onClicked: {
-                            emitterCreate()
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    Component {
-        id: emitterDelegate
-        Rectangle {
-            id: emitter
-            width: 200
-            height: parent.height
-            radius: 3
-            color: theme.emitterColor
-
-            Image {
-                source: "file:///" + _IconPath
-                width: 48
-                height: 48
-                anchors.margins: 8
-                anchors.left: parent.left
-                anchors.top: parent.top
-            }
-
-            Text {
-                id: nameLabel
-                anchors.left: parent.left
-                anchors.right: parent.right
-                height: 64
-                text: Name
-                font.pointSize: theme.textSize
-                color: theme.textColor
-                horizontalAlignment: Text.AlignHCenter
-                verticalAlignment: Text.AlignVCenter
-
-                MouseArea {
-                    anchors.fill: parent
-                    hoverEnabled: true
-                    onEntered: emitter.color = theme.hoverColor
-                    onExited: emitter.color = theme.emitterColor
-                    onClicked: {
-                        emitterSelected(Name)
-                    }
-                }
-            }
-
-            ListView {
-                id: functionList
-                anchors.fill: parent
-                anchors.margins: 3
-                anchors.topMargin: 64
-                spacing: 3
-                clip: true
-                model: _ChildModel
-
-                delegate: Component {
-                    Rectangle {
-                        id: emitterFunction
-                        anchors.left: parent.left
-                        anchors.right: parent.right
-                        height: 32
-                        radius: 3
-                        color: theme.functionColor
-
-                        MouseArea {
-                            anchors.fill: parent
-                            hoverEnabled: true
-                            onEntered: emitterFunction.color = theme.hoverColor
-                            onExited: emitterFunction.color = theme.functionColor
-                            onClicked: {
-                                functionSelected(Name, modelData)
-                            }
-                        }
-
-                        Image {
-                            id: remove
-                            anchors.top: parent.top
-                            anchors.right: parent.right
-                            anchors.margins: 4
-                            width: 24
-                            height: 24
-                            source: "qrc:/Images/fontawesome/close.svg"
-                            visible: false
-                        }
-
-                        ColorOverlay {
-                            anchors.fill: remove
-                            source: remove
-                            color: "#60ffffff"
-
-                            MouseArea {
-                                anchors.fill: parent
-                                hoverEnabled: true
-                                onEntered: parent.color = "#80ffffff"
-                                onExited: parent.color = "#60ffffff"
-                                onClicked: {
-                                    functionDelete(Name, modelData)
-                                }
-                            }
-                        }
-
-                        Text {
-                            id: nameLabel
-                            anchors.fill: parent
-                            anchors.margins: 3
-                            text: modelData
-                            color: theme.textColor
-                            font.pointSize: theme.textSize
-                            horizontalAlignment: Text.AlignLeft
-                            verticalAlignment: Text.AlignVCenter
-                        }
-
-                    }
-                }
-
-                Rectangle {
-                    id: deleteEmitter
-                    anchors.left: parent.left
-                    anchors.right: parent.right
-                    anchors.bottom: parent.bottom
-                    anchors.topMargin: 3
-                    height: 32
-                    radius: theme.frameRadius
-                    color: "#00000000"
-                    border.color: theme.red
-
-                    Text {
-                        id: deleteLabel
-                        anchors.fill: parent
-                        text: "Delete Emitter"
-                        color: theme.red
-                        font.pointSize: theme.textSize
-                        horizontalAlignment: Text.AlignHCenter
-                        verticalAlignment: Text.AlignVCenter
-                    }
-
-                    MouseArea {
-                        anchors.fill: parent
-                        hoverEnabled: true
-                        onEntered: {
-                            deleteEmitter.color = theme.redHover
-                            deleteLabel.color = theme.textColor
-                            deleteEmitter.border.color = "#00000000"
-                        }
-                        onExited: {
-                            deleteEmitter.color = "#00000000"
-                            deleteLabel.color = theme.red
-                            deleteEmitter.border.color = theme.red
-                        }
-                        onClicked: {
-                            emitterDelete(Name)
-                        }
-                    }
-                }
-
-                header: Component {
-                    Item {
-                        anchors.left: parent.left
-                        anchors.right: parent.right
-                        height: 32
-
-                        Rectangle {
-                            id: addFunction
-                            anchors.fill: parent
-                            anchors.bottomMargin: 3
-                            radius: theme.frameRadius
-                            color: theme.green
-
-                            Text {
-                                id: nameLabel
-                                anchors.fill: parent
-                                text: "Add Modifier"
-                                color: theme.textColor
-                                font.pointSize: theme.textSize
-                                horizontalAlignment: Text.AlignHCenter
-                                verticalAlignment: Text.AlignVCenter
-                            }
-
-                            MouseArea {
-                                anchors.fill: parent
-                                hoverEnabled: true
-                                onEntered: addFunction.color = theme.greenHover
-                                onExited: addFunction.color = theme.green
-                                onClicked: {
-                                    menu.open()
-                                }
-
-                                Menu {
-                                    id: menu
-                                    y: parent.height
-
-                                    MenuItem {
-                                        text: "Lifetime"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-                                    MenuItem {
-                                        text: "StartSize"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-                                    MenuItem {
-                                        text: "StartColor"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-                                    MenuItem {
-                                        text: "StartAngle"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-                                    MenuItem {
-                                        text: "StartPosition"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-
-                                    MenuItem {
-                                        text: "ScaleSize"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-                                    MenuItem {
-                                        text: "ScaleColor"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-                                    MenuItem {
-                                        text: "ScaleAngle"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-                                    MenuItem {
-                                        text: "Velocity"
-                                        onTriggered: functionCreate(Name, text)
-                                    }
-
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-        }
-    }
-
-}
diff --git a/modules/editor/particletools/templates/VisualEffect.vfx b/modules/editor/particletools/templates/VisualEffect.vfx
new file mode 100644
index 000000000..4218a3496
--- /dev/null
+++ b/modules/editor/particletools/templates/VisualEffect.vfx
@@ -0,0 +1,6 @@
+<document version="1">
+    <graph>
+        <nodes/>
+        <links/>
+    </graph>
+</document>
diff --git a/modules/editor/shadertools/converter/functions/customfunction.h b/modules/editor/shadertools/converter/functions/customfunction.h
index d433bd0f7..c82a4030f 100644
--- a/modules/editor/shadertools/converter/functions/customfunction.h
+++ b/modules/editor/shadertools/converter/functions/customfunction.h
@@ -109,7 +109,7 @@ class CustomFunction : public ShaderNode {
                                                                           values[2].toFloat()));
             case QMetaType::QVector4D: return QVariant::fromValue(Vector4(values[0].toFloat(), values[1].toFloat(),
                                                                           values[2].toFloat(), values[3].toFloat()));
-            case QMetaType::QImage: { Template value("", MetaType::type<Texture *>()); return QVariant::fromValue(value); }
+            case QMetaType::QImage: { return QVariant::fromValue(Template("", MetaType::name<Texture>())); }
             default: break;
         }
 
diff --git a/modules/editor/shadertools/converter/functions/texturesample.h b/modules/editor/shadertools/converter/functions/texturesample.h
index 53c319d56..f2d66efe1 100644
--- a/modules/editor/shadertools/converter/functions/texturesample.h
+++ b/modules/editor/shadertools/converter/functions/texturesample.h
@@ -71,7 +71,7 @@ class TextureObject : public TextureFunction {
     Q_INVOKABLE TextureObject() {
         m_outputs.push_back(std::make_pair("Texture", QMetaType::QImage));
 
-        m_path = Template("", MetaType::type<Texture *>());
+        m_path = Template("", MetaType::name<Texture>());
     }
 
     int32_t build(QString &code, QStack<QString> &stack,const AbstractNodeGraph::Link &link, int32_t &depth, int32_t &type) override {
@@ -115,7 +115,7 @@ class TextureSample : public TextureFunction {
         m_outputs.push_back(std::make_pair(b, QMetaType::Float));
         m_outputs.push_back(std::make_pair(a, QMetaType::Float));
 
-        m_path = Template("", MetaType::type<Texture *>());
+        m_path = Template("", MetaType::name<Texture>());
     }
 
     int32_t build(QString &code, QStack<QString> &stack,const AbstractNodeGraph::Link &link, int32_t &depth, int32_t &type) override {
diff --git a/modules/editor/shadertools/shaders/Billboard.vert b/modules/editor/shadertools/shaders/Billboard.vert
index d2736ba8d..8709d5496 100644
--- a/modules/editor/shadertools/shaders/Billboard.vert
+++ b/modules/editor/shadertools/shaders/Billboard.vert
@@ -38,16 +38,24 @@ void main(void) {
 
 #pragma vertex
 
-    vec4 worldPosition = instance.data[_instanceOffset];
-    vec4 sizeRot = instance.data[_instanceOffset + 1];
-    vec4 uvScaleDist = instance.data[_instanceOffset + 2];
-    vec4 uvOffset = instance.data[_instanceOffset + 3];
+    vec4 v0 = instance.data[_instanceOffset];
+    vec4 v1 = instance.data[_instanceOffset + 1];
+    vec4 v2 = instance.data[_instanceOffset + 2];
+    vec4 v3 = instance.data[_instanceOffset + 3];
 
-    _objectId = vec4(worldPosition.w, sizeRot.w, uvScaleDist.w, uvOffset.w);
+    vec3 worldPosition = v3.xyz;
+    vec3 sizeRot = v0.xyz;
+    vec2 uvScale = v1.xy;
+    vec2 uvOffset = v2.xy;
+
+    sizeRot.x *= vertex.x;
+    sizeRot.y *= vertex.y;
+
+    _objectId = vec4(v0.w, v1.w, v2.w, v3.w);
 
     float angle = sizeRot.z;
-    float x = cos(angle) * vertex.x + sin(angle) * vertex.y;
-    float y = sin(angle) * vertex.x - cos(angle) * vertex.y;
+    float x = cos(angle) * sizeRot.x + sin(angle) * sizeRot.y;
+    float y = sin(angle) * sizeRot.x - cos(angle) * sizeRot.y;
 
     vec3 target = g.cameraTarget.xyz;
     if(g.cameraProjection[2].w < 0.0f) {
@@ -58,18 +66,18 @@ void main(void) {
     vec3 right = normalize(cross(vec3(0.0f, 1.0f, 0.0f), normal));
     vec3 up = normalize(cross(normal, right));
 
-    vec3 v = (up * x + right * y) * vec3(sizeRot.xy, 1.0f) + worldPosition.xyz + PositionOffset;
+    vec3 v = (up * x + right * y) + worldPosition + PositionOffset;
 
     _vertex = g.projection * (_modelView * vec4(v, 1.0f));
     _view = normalize(v - camera);
 
 #ifdef USE_TBN
-    _n = vec3(0);
-    _t = vec3(0);
-    _b = vec3(0);
+    _n = vec3(0.0f);
+    _t = vec3(0.0f);
+    _b = vec3(0.0f);
 #endif
 
     _color = color;
-    _uv0 = uv0 * uvScaleDist.xy + uvOffset.xy;
+    _uv0 = uv0 * uvScale.xy + uvOffset.xy;
     gl_Position = _vertex;
 }
diff --git a/modules/uikit/src/components/abstractbutton.cpp b/modules/uikit/src/components/abstractbutton.cpp
index 227a4b108..1df7f779c 100644
--- a/modules/uikit/src/components/abstractbutton.cpp
+++ b/modules/uikit/src/components/abstractbutton.cpp
@@ -276,7 +276,7 @@ void AbstractButton::update() {
     }
     Vector4 color(m_normalColor);
 
-    bool hover = rectTransform()->isHovered(pos.x, pos.y);
+    bool hover = (m_background) ? m_background->rectTransform()->isHovered(pos.x, pos.y) : rectTransform()->isHovered(pos.x, pos.y);
     if(m_hovered != hover || hover) {
         m_currentFade = 0.0f;
         m_hovered = hover;
diff --git a/thirdparty/next/inc/core/metatype.h b/thirdparty/next/inc/core/metatype.h
index 48b6aff74..1fc5e0cc9 100644
--- a/thirdparty/next/inc/core/metatype.h
+++ b/thirdparty/next/inc/core/metatype.h
@@ -108,6 +108,12 @@ class NEXT_LIBRARY_EXPORT MetaType {
     }
 
     static const char *name(uint32_t type);
+
+    template<typename T>
+    static const char *name() {
+        return name(type(typeid(T)));
+    }
+
     static int size(uint32_t type);
     static void *construct(uint32_t type, void *where, const void *copy = nullptr);
     static void *create(uint32_t type, const void *copy = nullptr);
diff --git a/worldeditor/src/screens/propertyedit/property.cpp b/worldeditor/src/screens/propertyedit/property.cpp
index ad5f30ba8..7ab9a6df7 100644
--- a/worldeditor/src/screens/propertyedit/property.cpp
+++ b/worldeditor/src/screens/propertyedit/property.cpp
@@ -373,7 +373,7 @@ QVariant Property::qObjectVariant(const Variant &value, const std::string &typeN
     if(factory) {
         Object *object = (value.data() == nullptr) ? nullptr : *(reinterpret_cast<Object **>(value.data()));
         if(factory->first->canCastTo(gResource) || (editor == gAsset)) {
-            return QVariant::fromValue(Template(Engine::reference(object).c_str(), value.userType()));
+            return QVariant::fromValue(Template(Engine::reference(object).c_str(), MetaType::name(value.userType())));
         } else {
             Scene *scene = nullptr;
             Actor *actor = dynamic_cast<Actor *>(object);