diff --git a/ParticleGenerator/src/Particle/Particle.cpp b/ParticleGenerator/src/Particle/Particle.cpp
index 7313c91b4bb5ff6a1862d53d935a11678c5cf2e8..bd2ba6e20b604810b09438215221d6a50c966c9e 100644
--- a/ParticleGenerator/src/Particle/Particle.cpp
+++ b/ParticleGenerator/src/Particle/Particle.cpp
@@ -6,6 +6,6 @@ namespace pg {
     Particle::Particle(const ct::Point& position) 
     : Particle(0, position) {}
 
-    Particle::Particle(size_t birth, const ct::Point& position) 
-    : m_position(position), m_birth(birth) {}
+    Particle::Particle(size_t born, const ct::Point& position) 
+    : m_position(position), m_born(born) {}
 }
\ No newline at end of file
diff --git a/ParticleGenerator/src/Particle/Particle.hpp b/ParticleGenerator/src/Particle/Particle.hpp
index 116d06aba3c956da292e0d50ad5dd82bcec03180..411e025270437388f67a29d23ddf1a7d8c065106 100644
--- a/ParticleGenerator/src/Particle/Particle.hpp
+++ b/ParticleGenerator/src/Particle/Particle.hpp
@@ -1,27 +1,51 @@
 #pragma once
 
 #include <chrono>
+#include <vector>
+
 #include <CurveTools/CPU/CurveGenerator.hpp>
 
 namespace pg {	
 	class Particle {
 		private:
-			size_t m_birth;
+			size_t m_born;
+			ct::Point m_position;
 
 		protected:
-			ct::Point m_position;
+			
 
 		public:
-			Particle(const ct::Point& position = ct::Point(0.0));
-			Particle(size_t birth, const ct::Point& position);
+			Particle(const ct::Point& position = ct::Point());
+			Particle(size_t born, const ct::Point& position = ct::Point());
    virtual ~Particle() = default;
-
+			
+			inline size_t getBorn() const {return this->m_born;}
 			inline ct::Point getPosition() const {return this->m_position;}
-			inline size_t getBirth() const {return this->m_birth;}
 
+			inline bool isDead(size_t current_time, size_t max_time) const {return (current_time - this->m_born) > max_time;}
+
+			inline void setBorn(size_t born) {this->m_born = born;}
 			inline void setPosition(const ct::Point& position) {this->m_position = position;}
-			inline void setBirth(size_t time) {this->m_birth = time;}
 
+			inline void translate(const ct::Point& position) {this->m_position += position;}
 			virtual void update(double) = 0;
+
+			inline friend bool operator>(const Particle & p1, const Particle & p2) {return p1.m_born > p2.m_born;}
+			inline friend bool operator>=(const Particle & p1, const Particle & p2) {return p1 > p2 || p1.m_born == p2.m_born;}
+			inline friend bool operator<(const Particle & p1, const Particle & p2) {return p1.m_born < p2.m_born;}
+			inline friend bool operator<=(const Particle & p1, const Particle & p2) {return p1 < p2 || p1.m_born == p2.m_born;}
+
+			template <typename T>
+			static void purge(std::vector<T> & container, size_t current_time, size_t max_time) {
+        		for (auto it = container.begin(); it != container.end();) {
+					if (it->isDead(current_time, max_time)) {
+						it = container.erase(it);
+					}
+
+					if (it != container.end()) {
+						++it;
+					}
+        		}
+    		}
 	};
 }
\ No newline at end of file
diff --git a/ParticleGenerator/src/Particle/PathParticle.cpp b/ParticleGenerator/src/Particle/PathParticle.cpp
index b276abd2766f4056dd8b337496559217233f1af0..18b21543a58bd70fa7a5ab68ed4cac085a198750 100644
--- a/ParticleGenerator/src/Particle/PathParticle.cpp
+++ b/ParticleGenerator/src/Particle/PathParticle.cpp
@@ -2,18 +2,18 @@
 
 namespace pg {
 	PathParticle::PathParticle(ct::CurveGenerator* generator, const ct::Curve& path, double u) 
-	: Particle(), m_generator(generator), m_contrlPoints(path), m_positionVariation(), m_u(u) {
+	: Particle(), m_generator(generator), m_ctrlPoints(path), m_positionVariation(), m_u(u) {
 		if(!path.empty()) {
-			this->setPosition(this->m_contrlPoints.at(0));
+			this->setPosition(this->m_ctrlPoints.at(0));
 		}
 	}
 
 	PathParticle::PathParticle(size_t birth, ct::CurveGenerator* generator, const ct::Curve& controlPoints, double u) 
 	: PathParticle(generator, controlPoints, u) {
-		this->setBirth(birth);
+		this->setBorn(birth);
 	}
 
 	void PathParticle::update(double u) {
-		this->m_position = this->m_generator->operator()(this->m_contrlPoints, u);
+		this->setPosition(this->m_generator->operator()(this->m_ctrlPoints, u));
 	}
 }
diff --git a/ParticleGenerator/src/Particle/PathParticle.hpp b/ParticleGenerator/src/Particle/PathParticle.hpp
index 01357cd8628991d692e3ec0791baf7a614cb8c6c..4c308179c7a404cc5ecb3ce0b38802b07980e423 100644
--- a/ParticleGenerator/src/Particle/PathParticle.hpp
+++ b/ParticleGenerator/src/Particle/PathParticle.hpp
@@ -7,7 +7,7 @@ namespace pg {
 	class PathParticle : public Particle {
 		private:
 			ct::CurveGenerator* m_generator;
-			ct::Curve m_contrlPoints;
+			ct::Curve m_ctrlPoints;
 			glm::dvec3 m_positionVariation;
 			double m_u;
 
@@ -15,7 +15,7 @@ namespace pg {
 			PathParticle(size_t birth, ct::CurveGenerator* generator, const ct::Curve& controlPoints, double u = 0.0);
 			PathParticle(ct::CurveGenerator* generator, const ct::Curve& path, double u = 0.0);
 
-			inline const ct::Curve & getControlPoints() const {return this->m_contrlPoints;}
+			inline const ct::Curve & getControlPoints() const {return this->m_ctrlPoints;}
 			inline glm::dvec3 getPositionVariation() const {return m_positionVariation;}
 			inline double getParameterValue() const {return this->m_u;}
 
diff --git a/ParticleGenerator/src/Particle/PhysicsParticle.cpp b/ParticleGenerator/src/Particle/PhysicsParticle.cpp
index 2b9dc9d8e93b1a6fc21765b2d5c3daa38fff2fed..98d003350516108aeacd2e7d1c9162744c7d5bab 100644
--- a/ParticleGenerator/src/Particle/PhysicsParticle.cpp
+++ b/ParticleGenerator/src/Particle/PhysicsParticle.cpp
@@ -8,9 +8,9 @@ namespace pg {
 	: PhysicsParticle(0, position, velocity) {}
 
 	void PhysicsParticle::update(double t) {
-		m_acceleration -= glm::dvec3(m_friction) * m_velocity;
+		m_acceleration -= static_cast<glm::dvec3>(m_friction) * m_velocity;
 		m_velocity += m_acceleration;
 
-		this->m_position += this->m_velocity;
+		this->translate(this->m_velocity);
 	}
 }
\ No newline at end of file
diff --git a/ParticleGenerator/src/Particle/generator/ParticleGenerator.hpp b/ParticleGenerator/src/Particle/generator/ParticleGenerator.hpp
index f73c9aa1db4e01068dd7232ae3f0a879078a538b..525604d5c60b330ecc41b57d3c05a47fbc76c0d5 100644
--- a/ParticleGenerator/src/Particle/generator/ParticleGenerator.hpp
+++ b/ParticleGenerator/src/Particle/generator/ParticleGenerator.hpp
@@ -7,19 +7,18 @@ namespace pg {
 	class ParticleGenerator {
 		private:
 			double m_positionVariation;
-
-		protected:
 			ct::Point m_position;
+
 			
 		public:
 			ParticleGenerator(const ct::Point& position = ct::Point(), double positionVariation = 0.0);
+			
+			inline double getPositionVariation() const {return this->m_positionVariation;}
+			inline ct::Point getPosition() const {return this->m_position;}
 
-			ct::Point getPosition() const;
-			double getPositionVariation() const;
-
-			void setPosition(const ct::Point& position);
-			void setPositionVariation(double positionVariation);
-
+			inline void setPositionVariation(double positionVariation) {this->m_positionVariation = positionVariation;}
+			inline void setPosition(const ct::Point& position) {this->m_position = position;}
+			
 			virtual std::vector<T> generate(size_t count, size_t birth = 0) const = 0;
  
 			inline std::vector<T> operator()(size_t count, size_t birth = 0) const {return this->generate(count, birth);}
@@ -27,27 +26,5 @@ namespace pg {
 
 	template<typename T>
 	ParticleGenerator<T>::ParticleGenerator(const ct::Point& position, double positionVariation) 
-	: m_position(position), m_positionVariation(positionVariation) {
-
-	}
-
-	template<typename T>
-	ct::Point ParticleGenerator<T>::getPosition() const {
-		return m_position;
-	}
-
-	template<typename T>
-	double ParticleGenerator<T>::getPositionVariation() const {
-		return m_positionVariation;
-	}
-
-	template<typename T>
-	void ParticleGenerator<T>::setPosition(const ct::Point& position) {
-		m_position = position;
-	}
-
-	template<typename T>
-	void ParticleGenerator<T>::setPositionVariation(double positionVariation) {
-		m_positionVariation = positionVariation;
-	}
+	: m_position(position), m_positionVariation(positionVariation) {}
 }
\ No newline at end of file
diff --git a/ParticleGenerator/src/Particle/generator/PathParticleGenerator.hpp b/ParticleGenerator/src/Particle/generator/PathParticleGenerator.hpp
index 1fb87e2d0611fdf1a1918e757a12bf7cddf5d4a1..3c2a9611f5de9767bb4b50dfdbda8629e278b69e 100644
--- a/ParticleGenerator/src/Particle/generator/PathParticleGenerator.hpp
+++ b/ParticleGenerator/src/Particle/generator/PathParticleGenerator.hpp
@@ -10,7 +10,7 @@ namespace pg {
 			ct::CurveGenerator * m_generator;
 
 		public:
-			PathParticleGenerator(ct::CurveGenerator * generator, const ct::Curve& controlPoints, const ct::Point& position,  double positionVariation);
+			PathParticleGenerator(ct::CurveGenerator * generator, const ct::Curve& controlPoints, const ct::Point& position = ct::Point(), double positionVariation = 0.0);
 
 			inline const ct::Curve& getControlPoint() const {return this->m_controlPoints;}
 			inline void setControlPoint(const ct::Curve& points) {this->m_controlPoints = points;}
diff --git a/ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.cpp b/ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.cpp
index 98957a8eb55d937ad547aa77f4159a06838dc88d..8ccf26faeaee0a85d1a5e6034c22435450e47f1f 100644
--- a/ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.cpp
+++ b/ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.cpp
@@ -5,15 +5,13 @@
 namespace pg
 {
 	PhysicsParticleGenerator::PhysicsParticleGenerator(const ct::Point& position, double positionVariation, const glm::dvec3& velocity) 
-	: 	ParticleGenerator(position, positionVariation),
+	: ParticleGenerator(position, positionVariation),
 		m_velocity(velocity),
 		m_acceleration(),
 		m_friction(),
 		m_velocityVariation(),
 		m_accelerationVariation(),
-		m_frictionVariation() {
-
-	}
+		m_frictionVariation() {}
 
 	std::vector<PhysicsParticle> PhysicsParticleGenerator::generate(size_t count, size_t birth) const {
 		std::random_device device;
@@ -25,13 +23,13 @@ namespace pg
 
 		ureal_dist p(-positionVariation, positionVariation);
 	
-		ureal_dist vx(-this->m_velocityVariation.x, this->m_velocityVariation.x);
-		ureal_dist vy(-this->m_velocityVariation.y, this->m_velocityVariation.y);
-		ureal_dist vz(-this->m_velocityVariation.z, this->m_velocityVariation.z);
+		ureal_dist vx(-this->m_velocityVariation.lower.x, this->m_velocityVariation.upper.x);
+		ureal_dist vy(-this->m_velocityVariation.lower.y, this->m_velocityVariation.upper.y);
+		ureal_dist vz(-this->m_velocityVariation.lower.z, this->m_velocityVariation.upper.z);
 
-		ureal_dist ax(-this->m_accelerationVariation.x, this->m_accelerationVariation.x);
-		ureal_dist ay(-this->m_accelerationVariation.y, this->m_accelerationVariation.y);
-		ureal_dist az(-this->m_accelerationVariation.z, this->m_accelerationVariation.z);
+		ureal_dist ax(-this->m_accelerationVariation.lower.x, this->m_accelerationVariation.upper.x);
+		ureal_dist ay(-this->m_accelerationVariation.lower.y, this->m_accelerationVariation.upper.y);
+		ureal_dist az(-this->m_accelerationVariation.lower.z, this->m_accelerationVariation.upper.z);
 
 		ureal_dist fx(0.0, this->m_frictionVariation.x);
 		ureal_dist fy(0.0, this->m_frictionVariation.y);
@@ -40,33 +38,17 @@ namespace pg
 		std::vector<PhysicsParticle> particles(count);
 
 		for (size_t i = 0; i < count; ++i) {
-			PhysicsParticle particle(birth);
-
-			ct::Point position = this->m_position;
-			glm::dvec3 velocity = this->m_velocity;
-			glm::dvec3 acceleration = this->m_acceleration;
-			glm::dvec3 friction = this->m_friction;
-
-			position.x += p(randomEngine);
-			position.y += p(randomEngine);
-			position.z += p(randomEngine);
-
-			velocity.x += vx(randomEngine);
-			velocity.y += vy(randomEngine);
-			velocity.z += vz(randomEngine);
+			PhysicsParticle particle(birth, this->getPosition());
 
-			acceleration.x += ax(randomEngine);
-			acceleration.y += ay(randomEngine);
-			acceleration.z += az(randomEngine);
+			particle.translate({p(randomEngine), p(randomEngine), p(randomEngine)});
 
-			friction.x += fx(randomEngine);
-			friction.y += fy(randomEngine);
-			friction.z += fz(randomEngine);
+			glm::dvec3 velocityVariation = {vx(randomEngine), vy(randomEngine), vz(randomEngine)};
+			glm::dvec3 accelerationVariation = {ax(randomEngine), ay(randomEngine), az(randomEngine)};
+			glm::dvec3 frictionVariation = {fx(randomEngine), fy(randomEngine), fz(randomEngine)};
 
-			particle.setPosition(position);
-			particle.setVelocity(velocity);
-			particle.setAcceleration(acceleration);
-			particle.setFriction(friction);
+			particle.setVelocity(this->m_velocity + velocityVariation);
+			particle.setAcceleration(this->m_acceleration + accelerationVariation);
+			particle.setFriction(this->m_friction + frictionVariation);
 
 			particles.push_back(particle);
 		}
diff --git a/ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.hpp b/ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.hpp
index fd86738d150fd32ecb0915d5b6b84d54bce52654..8e6789305c247b6738c52652b5f66feef6483af4 100644
--- a/ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.hpp
+++ b/ParticleGenerator/src/Particle/generator/PhysicsParticleGenerator.hpp
@@ -4,13 +4,19 @@
 #include "../PhysicsParticle.hpp"
 
 namespace pg {
+	template <typename T>
+	struct Interval {
+		T upper;
+		T lower;
+	};
+
 	class PhysicsParticleGenerator : public ParticleGenerator<PhysicsParticle> {
 		private:
 			glm::dvec3 m_velocity;
 			glm::dvec3 m_acceleration;
 			glm::dvec3 m_friction;
-			glm::dvec3 m_velocityVariation;
-			glm::dvec3 m_accelerationVariation;
+			Interval<glm::dvec3> m_velocityVariation;
+			Interval<glm::dvec3> m_accelerationVariation;
 			glm::dvec3 m_frictionVariation;
 
 		public:
@@ -19,15 +25,16 @@ namespace pg {
 			inline const glm::dvec3 & getVelocity() const {return this->m_velocity;}
 			inline const glm::dvec3 & getAcceleration() const {return this->m_acceleration;}
 			inline const glm::dvec3 & getFriction() const {return this->m_friction;}
-			inline const glm::dvec3 & getVelocityVariation() const {return this->m_velocityVariation;}
-			inline const glm::dvec3 & getAccelerationVariation() const {return this->m_accelerationVariation;}
+			inline const Interval<glm::dvec3> & getVelocityVariation() const {return this->m_velocityVariation;}
+			inline const Interval<glm::dvec3> & getAccelerationVariation() const {return this->m_accelerationVariation;}
 			inline const glm::dvec3 & getFrictionVariation() const {return this->m_frictionVariation;}
 
 			inline void setVelocity(const glm::dvec3 & velocity) {this->m_velocity = velocity;}
 			inline void setAcceleration(const glm::dvec3 & acceleration) {this->m_acceleration = acceleration;}
 			inline void setFriction(const glm::dvec3  & friction) {this->m_friction = friction;}
-			inline void setVelocityVariation(const glm::dvec3 & velocityVariation) {this->m_velocityVariation = velocityVariation;}
-			inline void setAccelerationVariation(const glm::dvec3 & accelerationVariation) {this->m_accelerationVariation = accelerationVariation;}
+
+			inline void setVelocityVariation(const Interval<glm::dvec3> & velocityVariation) {this->m_velocityVariation = velocityVariation;}
+			inline void setAccelerationVariation(const Interval<glm::dvec3> & accelerationVariation) {this->m_accelerationVariation = accelerationVariation;}
 			inline void setFrictionVariation(const glm::dvec3 & frictionVariation) {this->m_frictionVariation = frictionVariation;}
 
 			std::vector<PhysicsParticle> generate(size_t count, size_t birth = 0) const override;
diff --git a/ParticleGenerator/src/graphic/buffer/DynamicBuffer.cpp b/ParticleGenerator/src/graphic/buffer/DynamicBuffer.cpp
index 096c75906195f8336a80e8d0a65cd214eb07ca96..bbee32cf84d47e286ff6be637cac317b8f33564b 100644
--- a/ParticleGenerator/src/graphic/buffer/DynamicBuffer.cpp
+++ b/ParticleGenerator/src/graphic/buffer/DynamicBuffer.cpp
@@ -118,7 +118,7 @@ namespace pg {
             
         if(pos < this->_size) {
             this->bind();
-            uint8_t * writer = static_cast<uint8_t *>(glMapBuffer(Y,GL_READ_WRITE));
+            uint8_t * writer = static_cast<uint8_t *>(glMapBuffer(Y, GL_READ_WRITE));
             memmove(writer + (pos + vbo._size) * sizeof(T), writer + (pos * sizeof(T)), (this->_size-pos) * sizeof(T));
             glUnmapBuffer(Y);
         }
diff --git a/ParticleGenerator/src/graphic/buffer/ElementBuffer.cpp b/ParticleGenerator/src/graphic/buffer/ElementBuffer.cpp
index 62839a27c8a7e8cb0d5f4267aafb3014b93eab92..c664fff523965b6b4881c23d0486fe9d5dda9b6e 100644
--- a/ParticleGenerator/src/graphic/buffer/ElementBuffer.cpp
+++ b/ParticleGenerator/src/graphic/buffer/ElementBuffer.cpp
@@ -37,12 +37,12 @@ namespace pg {
 
         if(this->_id != 0) {
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-            glDeleteBuffers(1,&this->_id);
+            glDeleteBuffers(1, &this->_id);
         }
 
-        glGenBuffers(1,&this->_id);
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,this->_id);
-        glBufferData(GL_ELEMENT_ARRAY_BUFFER,this->max_size()*sizeof(unsigned int),vertices.size() == 0 ? NULL : std::vector<unsigned int>(vertices).data(),this->_mode);
+        glGenBuffers(1, &this->_id);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->_id);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->max_size()*sizeof(unsigned int),vertices.size() == 0 ? NULL : std::vector<unsigned int>(vertices).data(), this->_mode);
 
     }
 
diff --git a/ParticleGenerator/src/graphic/buffer/VerticeBuffer.cpp b/ParticleGenerator/src/graphic/buffer/VerticeBuffer.cpp
index 5abd690eae1d1d4abf9970235c879da4309ae80d..02fe4ff6b11cde4fe4c321d08a684f559d87cc54 100644
--- a/ParticleGenerator/src/graphic/buffer/VerticeBuffer.cpp
+++ b/ParticleGenerator/src/graphic/buffer/VerticeBuffer.cpp
@@ -46,7 +46,7 @@ namespace pg {
         this->_vao->bind();
 
         if(this->_id != 0) {
-            glBindBuffer(GL_ARRAY_BUFFER,0);
+            glBindBuffer(GL_ARRAY_BUFFER, 0);
             glDeleteBuffers(1, &this->_id);
         }
 
diff --git a/ParticleGenerator/src/main.cpp b/ParticleGenerator/src/main.cpp
index 38f8c6790e413cdbac789cc72b1d9b59794f0403..0f8108ed0d45d5ca9babce45459729fe846e922a 100644
--- a/ParticleGenerator/src/main.cpp
+++ b/ParticleGenerator/src/main.cpp
@@ -42,18 +42,6 @@ void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
     camera->onScroll(static_cast<int>(yoffset));
 }
 
-void kill_old_particle(std::vector<pg::PhysicsParticle> & container, double current_time, double max_time) {
-    for (auto it = container.begin(); it != container.end();) {
-		if (current_time - it->getBirth() > max_time) {
-			it = container.erase(it);
-        }
-
-		if (it != container.end()) {
-			++it;
-        }
-	}
-}
-
 int main()
 {
     try {
@@ -214,7 +202,7 @@ int main()
             auto end = std::chrono::system_clock::now();
             if(duration_cast<std::chrono::milliseconds>(end - start).count() >= 500) {
                 start = std::chrono::system_clock::now();
-                kill_old_particle(particles, glfwGetTime(), 5);
+                pg::Particle::purge<pg::PhysicsParticle>(particles, glfwGetTime(), 5);
                 std::vector<pg::PhysicsParticle> newParticles = generator(5, glfwGetTime());
                 particles.insert(particles.end(), newParticles.begin(), newParticles.end());
             }