diff --git a/.gitignore b/.gitignore
index c12916f..1d036fd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,2 @@
-
-*.pyc
-*.pyc
 *.pyc
+__pycache__/classes.cpython-311.pyc
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..6324d40
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.14
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/__pycache__/classes.cpython-311.pyc b/__pycache__/classes.cpython-311.pyc
index b2272fa..d6542b3 100644
Binary files a/__pycache__/classes.cpython-311.pyc and b/__pycache__/classes.cpython-311.pyc differ
diff --git a/classes.py b/classes.py
index 8dc849e..52a5092 100644
--- a/classes.py
+++ b/classes.py
@@ -2,11 +2,13 @@
 import math
 import pygame
 import random
+from typing import Tuple, Union
+
 class plane:
 
     g = 9.8
 
-    def __init__(self, size:tuple[int,int], skewX:int = 0, skewY:int = 0, contents:list = []) -> None:
+    def __init__(self, size:tuple[int,int], screen, skewX:int = 0, skewY:int = 0, contents:list = []) -> None:
         
         self.skewX = 0
         self.skewY = 0
@@ -15,6 +17,9 @@ def __init__(self, size:tuple[int,int], skewX:int = 0, skewY:int = 0, contents:l
         self.forceY = 0
 
         self.sizeX, self.sizeY = size[0]/10, size[1]/10
+        self.screenW, self.screenH = pygame.display.Info().current_w, pygame.display.Info().current_h
+        self.screen = screen
+
         self.contents = contents
         self.positions = []
 
@@ -33,15 +38,18 @@ def addAngle(self, x, y):
         self.skewX += y
         self.maxAngle()
 
-    def followMouse(self,screen):
-        w, h = pygame.display.Info().current_w, pygame.display.Info().current_h
-        unitX, unitY = (2*math.pi)/w, (2*math.pi)/w
+    def followMouse(self):
+        unitX, unitY = (2*math.pi)/self.screenW, (2*math.pi)/self.screenH
         
-        x = pygame.mouse.get_pos()[0] - w/2
-        y = pygame.mouse.get_pos()[1] - h/2
+        x = pygame.mouse.get_pos()[0] - self.screenW/2
+        y = pygame.mouse.get_pos()[1] - self.screenH/2
 
         self.setAngle(x * unitX, y * unitY)
-        
+
+    def update(self, deltaTime, force):
+        for particle in self.contents:
+            particle.updatePos(deltaTime, force)
+            particle.draw(self.screen)     
 
     def force(self):
         self.forceX = plane.g * math.sin(self.skewX)
@@ -49,19 +57,32 @@ def force(self):
 
         return (self.forceX, self.forceY)
     
-    def indicator(self,screen):
+    def indicator(self):
         w, h = pygame.display.Info().current_w, pygame.display.Info().current_h
         unitX, unitY = w/(2*math.pi), h/(2*math.pi)
         center = (round(w/2),round(h/2))
         end_pos = (round( self.skewX * unitX + w/2 ), round( self.skewY * unitY + h/2 ))
-        pygame.draw.line(screen,(110,100,110), center, (end_pos))
+        pygame.draw.line(self.screen,(110,100,110), center, (end_pos))
+
+    def drawGrid(self):
+        for i in range(0,self.screenW, 10):
+            pygame.draw.line(self.screen, (0,10,30), (i,0), (i,self.screenH))
 
-    def updateSize(self, screen):
+        for i in range(0,self.screenH, 10):
+            pygame.draw.line(self.screen, (0,10,30), (0, i), (self.screenW, i))
+
+    def updateSize(self):
         self.sizeX, self.sizeY = pygame.display.Info().current_w/10 , pygame.display.Info().current_h/10
 
+    def clear(self):
+        self.contents = []
+        self.positions = []
+        dust.id = 0
+
 class dust:
 
     id = 0
+    dampCollisions = 5
 
     def __init__(self, plane, pos:tuple[int,int], mass:int = 1, color:str = False, vel:tuple[int,int] = (0, 0)) -> None:
         
@@ -78,10 +99,8 @@ def __init__(self, plane, pos:tuple[int,int], mass:int = 1, color:str = False, v
         else:
             self.color = (random.randint(30,255),random.randint(30,255),random.randint(30,255))
 
-        if self.pos() not in self.plane.positions:
-            self.plane.contents.append(self)
-        else:
-            del self
+        self.plane.contents.append(self)
+        self.plane.positions.append(self.pos())
 
         if not (0<self.posX<self.plane.sizeX or 0<self.posY<self.plane.sizeY):
             raise ValueError('dust must be inside your plane!!!')
@@ -95,22 +114,27 @@ def pos(self):
         
     def updatePos(self, deltaTime, force):
 
-        velX = self.velX + force[0]*deltaTime/self.mass * 1000
-        velY = self.velY + force[1]*deltaTime/self.mass * 1000
-
-        x = self.posX + velX * deltaTime
-        y = self.posY + velY * deltaTime
+        velX = self.velX + force[0]*deltaTime/self.mass * 300
+        velY = self.velY + force[1]*deltaTime/self.mass * 300
 
+        x = self.posX + velX * deltaTime * 10
+        y = self.posY + velY * deltaTime * 10
+        
         if not 0.1<x<self.plane.sizeX-0.1: #i wasted 4 hours here trying to fix collission and all i had to do was use 0.01 instead of 0.1 kms
                 x = self.posX
+                self.velX *= -1 * dust.dampCollisions
         
         if not 0.01<y<self.plane.sizeY-0.01:
                 y = self.posY
+                self.velY *= -1 * dust.dampCollisions
 
         newPos = self.gridPos(x,y)
-        
-        if newPos in self.plane.positions:
-            x, y = self.posX, self.posY
+        for id, pos in enumerate(self.plane.positions):
+            if newPos == pos and id != self.id:
+            
+                x, y = self.posX, self.posY
+                self.velX *= -1 * dust.dampCollisions
+                self.velY *= -1 * dust.dampCollisions
 
             # if (dust.gridPos(newPos[0], self.posY)) not in self.plane.positions:
             #     x = self.posX
@@ -123,8 +147,53 @@ def updatePos(self, deltaTime, force):
         self.posX, self.posY = x, y
 
 
-        self.plane.positions.append(self.pos())
+        self.plane.positions[self.id] = self.pos()
+        
 
     def draw(self,screen):
         x,y = self.pos()
-        pygame.draw.rect(screen, self.color,(x,y,10,10))
+        pygame.draw.rect(screen, self.color,(x,y,10,10),5,2)
+
+
+class Button:
+    def __init__(
+        self,
+        pos: Tuple[int, int],
+        size: Tuple[int, int],
+        text: str,
+        text_color: Union[str, Tuple[int, int, int]],
+        bg_color: Union[str, Tuple[int, int, int]],
+        method: callable = lambda: None,
+    ) -> None:
+        self.rect = pygame.Rect(pos, size)
+        self.font = pygame.font.SysFont("Arial", size[1])
+        self.text_surf = self.font.render(text, False, text_color)
+
+        self.color = bg_color
+        self.text = text
+        self.func = method
+
+        self._text_pos = self.text_surf.get_rect(center=self.rect.center).topleft
+
+        self._is_pressed = False
+
+    def draw(self, surface: pygame.Surface) -> None:
+        """Draws the pygame.Rect and font"""
+        pygame.draw.rect(surface, self.color, self.rect)
+        surface.blit(
+            self.text_surf,
+            self._text_pos,
+        )
+
+    def handle_events(self, event: pygame.event.Event) -> None:
+        """Put this inside of your event loop"""
+        if event.type == pygame.MOUSEBUTTONDOWN:
+            if event.button == 1 and self.rect.collidepoint(event.pos):
+                self._is_pressed = True
+            else:
+                self._is_pressed = False
+
+        elif event.type == pygame.MOUSEBUTTONUP:
+            if self._is_pressed and self.rect.collidepoint(event.pos):
+                self.func()
+            self._is_pressed = False
diff --git a/main.py b/main.py
index 799779f..465258c 100644
--- a/main.py
+++ b/main.py
@@ -1,69 +1,91 @@
+# /// script
+# dependencies = [
+#  "plyer",
+# ]
+# ///
+
 from classes import *
 import time
 import pygame
 import asyncio
-import plyer
-
-
 
 try:
+    import plyer
     plyer.accelerometer.enable()
-    if plyer.accelerometer.acceleration[0] is None:
-        accel = False
-        raise ValueError
-
-    accel = True
+    accel = False
+    for _ in range(25):
+        if plyer.accelerometer.get_acceleration()[0] != plyer.accelerometer.get_acceleration()[1]:
+            accel = True
+            break
+            
 except Exception as e:
     accel = False
 
+#F this i quit
+accel = True
+
 pygame.init()
 clock = pygame.time.Clock()
 
 previous_time = time.time()
 height, width = 700,700
-screen = pygame.display.set_mode((width,height), flags= pygame.RESIZABLE)
-surface = plane((width/10,height/10))
+screen = pygame.display.set_mode((width,height), flags = pygame.RESIZABLE)
+surface = plane((width/10,height/10), screen = screen)
 
+clear_button = Button((50,10),(80,40),"clear", (150,150,150), (5,10,30), surface.clear)
 
+
+
+pygame.mouse.set_pos((height/2, width/2))
+
+last_touched = time.time()
 async def main():
-    global previous_time, accel
+
+    global accel, previous_time
+
     while True:
 
         clock.tick()
         for event in pygame.event.get():
+
             if event.type == pygame.QUIT:
                 pygame.quit()
                 break
 
+
             if event.type == pygame.KEYDOWN:
-                surface.contents = []
+                surface.clear()
 
-        if pygame.mouse.get_pressed()[0]:
-            mX, mY = pygame.mouse.get_pos()
-            surface.contents.append(dust(surface, (mX/10, mY/10)))
+            clear_button.handle_events(event)
 
-        if accel:
-            surface.setAngle(plyer.accelerometer.acceleration[:-1])
-        else:
-            surface.followMouse(surface)
+        if pygame.mouse.get_pressed()[0]:
+            if time.time() - last_touched >= 0.03:
+                mX, mY = pygame.mouse.get_pos()
+                surface.contents.append(dust(surface, (mX/10, mY/10),mass = random.randint(10, 30)/10))
+                last_touched = time.time()
 
         #Loop variables
         deltaTime = time.time() - previous_time
         previous_time = time.time()
-        force = surface.force()
         
-        #Particle updates
-        for particle in surface.contents:
-            particle.updatePos(deltaTime, force)
-            particle.draw(screen)
+        if accel:
+           force = (-1 * plyer.accelerometer.get_acceleration()[0], plyer.accelerometer.get_acceleration()[1])
+        else:
+            surface.followMouse()
+            force = surface.force()
+
+        clear_button.draw(screen)
+        surface.drawGrid()
+        surface.indicator()
         
+        #Particle updates
+        surface.update(deltaTime , force)
+
         pygame.display.set_caption(f"pixel-dust | trimpta | FPS: {clock.get_fps():.0f} | PC: {len(surface.contents)}")
-        surface.indicator(screen)
-        surface.updateSize(screen)
         pygame.display.update()
-        screen.fill((0,0,0))
+        screen.fill((5,1,20))
 
-        surface.positions = []
+        surface.updateSize()
 
         await asyncio.sleep(0)
 
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..d5c8b31
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,10 @@
+[project]
+name = "pixel-dust"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "plyer>=2.1.0",
+    "pygame-ce>=2.5.7",
+]
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 62621d5..0000000
--- a/requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-Plyer >= 2.1.0
diff --git a/test.py b/test.py
deleted file mode 100644
index 60f5e2d..0000000
--- a/test.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from classes import *
-import time
-import pygame
-pygame.init()
-
-previous_time = time.time()
-height, width = 500,500
-screen = pygame.display.set_mode((width,height))
-
-surface = plane((width/10,height/10))
-surface.setAngle(0,90)
-
-particle1 = dust(surface, (15,15))
-particle2 = dust(surface, (14,12))
-particle3 = dust(surface, (10,10))
-
-while True:
-
-    # #Pygame events iteration
-    # for event in pygame.event.get():
-    #     if event.type == pygame.quit():
-    #         pygame.quit()
-    #         break
-
-    #     if event.type == pygame.MOUSEWHEEL:
-    #         if pygame.key.get_pressed[pygame.K_LSHIFT]:
-    #             surface.addAngle(0,event.y)
-    #         else:
-    #             surface.addAngle(event.y, 0)
-
-    #Loop variables
-    deltaTime = time.time() - previous_time
-    previous_time = time.time()
-    screen.fill((0,0,0))
-    force = surface.force()
-    
-    #Particle updates
-    for particle in surface.contents:
-        particle.updatePos(deltaTime, force)
-        particle.draw(screen)
-
-    pygame.display.update()
-    surface.positions = []
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..ee07a87
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,41 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "pixel-dust"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "plyer" },
+    { name = "pygame-ce" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "plyer", specifier = ">=2.1.0" },
+    { name = "pygame-ce", specifier = ">=2.5.7" },
+]
+
+[[package]]
+name = "plyer"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/85/f61425aa9be1f9108eec1c13861c1e11c9a04eb786eb4832a8f7188317df/plyer-2.1.0.tar.gz", hash = "sha256:65b7dfb7e11e07af37a8487eb2aa69524276ef70dad500b07228ce64736baa61", size = 121371, upload-time = "2022-11-12T13:36:48.978Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/89/a41c2643fc8eabeb84791acb9d0e4d139b1e4b53473cc4dae947b5fa33ed/plyer-2.1.0-py2.py3-none-any.whl", hash = "sha256:1b1772060df8b3045ed4f08231690ec8f7de30f5a004aa1724665a9074eed113", size = 142266, upload-time = "2022-11-12T13:36:47.181Z" },
+]
+
+[[package]]
+name = "pygame-ce"
+version = "2.5.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e9/0d/bb6a6fdf1b227c0bb9a44437a70962a3854bcc541533c261e5021a5ee691/pygame_ce-2.5.7.tar.gz", hash = "sha256:86beb797cd73c141299a29b56f7df2b0543fbdc81d428022458329ff694aaa51", size = 5935870, upload-time = "2026-03-02T09:26:59.005Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/08/9fe0003d69077ff8faff242a85260b8a192d3b7111c02332b8b2f515d40c/pygame_ce-2.5.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:addfbf7d119647eec157d611f463e5d572836fa74d0d222c59210294ed618b9d", size = 17211017, upload-time = "2026-03-02T09:26:30.243Z" },
+    { url = "https://files.pythonhosted.org/packages/40/c7/217c5430c8c612879162beb2d18cb10ad8b1b4db6ce03245289a3de6bc1b/pygame_ce-2.5.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1c92feb289e34ac323a7b62b91d230a4e32b44059c4d7fb95631e504b1d9b365", size = 12710845, upload-time = "2026-03-02T09:26:33.165Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a4/6fb0054bfb2522c4ad3ff82ecbc9c1a3c6694c50d24f2451717121636a1d/pygame_ce-2.5.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5c1ed4100311015cc67d24fe4e4d7c2f4cb25c34e043545061271c1d018c02d4", size = 12812020, upload-time = "2026-03-02T09:26:35.953Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/9b/0e0996573a9dd4bb34874c10643224a72372818242e07486c9eb4a22eebb/pygame_ce-2.5.7-cp314-cp314-win32.whl", hash = "sha256:1b7e641af3aeac92bb7e4df1402d6802271f4bd09c747d2665f154ef9b07a4e6", size = 9968590, upload-time = "2026-03-02T09:26:38.517Z" },
+    { url = "https://files.pythonhosted.org/packages/96/96/c94d0e508954093e37a77b03101a3cf51a242e02cc0ec726edcb117f8885/pygame_ce-2.5.7-cp314-cp314-win_amd64.whl", hash = "sha256:595f4257c15fed11cd816ae0bfabad3d99f8f04a000d7d164a22c0f9afd6cb65", size = 10581240, upload-time = "2026-03-02T09:26:41.139Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bb/93c5dadb66ac9733ca52952e063cce117a9312d6f97facd5dc4932f3d777/pygame_ce-2.5.7-cp314-cp314-win_arm64.whl", hash = "sha256:3e6ce74fd5a5f146f1bcf0224ae3e880c733917a9edbb53f790329d235520433", size = 11057480, upload-time = "2026-03-02T09:26:43.871Z" },
+]