Any help on optimizing this infinite terrain script?

Hello this is my infinite terrain script for my game. It works but its incredibly laggy when the player moves around but it does work. I will not share my chunk script because its not necessary because nothing really is called on the chunks other then updating position. NOTE: I know this script is not very good but I tried based on what I know which is why I came here for help to learn more :D thanks

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
 public class GEN_InfiniteTerrain : MonoBehaviour
 {
     public GameObject targetObject;
     public GameObject chunkObject;
     public int chunkSize;
     public float unitSize;
 
     public int renderDistance;
     Dictionary<Vector2, GameObject> gridOfChunks = new Dictionary<Vector2, GameObject>();
     List<Vector2> expectedChunkGridPositions = new List<Vector2>();
 
     public float noiseScale;
 
     // Infinite terrain values
     float absoluteChunkSize;
 
     private void Start()
     {
         // Calculate absolute chunk size
         GetAbsoluteChunkSize();
 
         // Generate base world
         GenerateBase();
     }
 
     Vector2 lastTargetGridPosition = Vector2.zero;
     private void LateUpdate()
     {
         // Get the targets position in world space
         Vector3 targetAbsolutePosition = targetObject.transform.position;
 
         // Convert the targets world position to grid position (/ 10 * 10 is just rounding to 10)
         Vector2 targetGridPosition = new Vector2();
         targetGridPosition.x = Mathf.RoundToInt(targetAbsolutePosition.x / 10) * 10 / absoluteChunkSize;
         targetGridPosition.y = Mathf.RoundToInt(targetAbsolutePosition.z / 10) * 10 / absoluteChunkSize;
 
         if (targetGridPosition - lastTargetGridPosition != Vector2.zero)
         {
             GenerateExpectedChunkAreas(targetGridPosition);
             UpdateChunkPositions(targetGridPosition);
         }
 
         lastTargetGridPosition = targetGridPosition;
     }
 
     void GenerateBase()
     {
         for (int x = -renderDistance / 2; x < renderDistance / 2; x++)
         {
             for (int z = -renderDistance / 2; z < renderDistance / 2; z++)
             {
                 Vector2 gridPosition = new Vector2(x, z);
                 Vector3 worldPosition = new Vector3(x * (unitSize * chunkSize), 0, z * (unitSize * chunkSize));
                 GameObject chunk = Instantiate(chunkObject, worldPosition, Quaternion.identity);
                 chunk.GetComponent<GEN_Chunk>().gridPosition = gridPosition;
                 gridOfChunks.Add(gridPosition, chunk);
             }
         }
         GenerateExpectedChunkAreas(Vector2.zero);
     }
 
     void GenerateExpectedChunkAreas(Vector2 targetGridPosition)
     {
         expectedChunkGridPositions.Clear();
         for (int x = -renderDistance / 2; x < renderDistance / 2; x++)
         {
             for (int z = -renderDistance / 2; z < renderDistance / 2; z++)
             {
                 Vector2 gridPosition = new Vector2(x, z) + targetGridPosition;
                 expectedChunkGridPositions.Add(gridPosition);
             }
         }
     }
 
     void UpdateChunkPositions(Vector2 targetGridPosition)
     {
         List<Vector2> positionsWithoutChunks = new List<Vector2>();
         List<Vector2> positionsWithOldChunks = new List<Vector2>();
 
         for (int chunkCount = 0, x = -renderDistance / 2; x < renderDistance / 2; x++)
         {
             for (int z = -renderDistance / 2; z < renderDistance / 2; z++)
             {
                 Vector2 gridPosition = new Vector2(x, z) + targetGridPosition;
                 
                 if(!gridOfChunks.ContainsKey(gridPosition))
                 {
                     positionsWithoutChunks.Add(gridPosition);
                 }
                 chunkCount++;
             }
         }
 
         foreach (GameObject chunk in gridOfChunks.Values)
         {
             if(!expectedChunkGridPositions.Contains(chunk.GetComponent<GEN_Chunk>().gridPosition))
             {
                 positionsWithOldChunks.Add(chunk.GetComponent<GEN_Chunk>().gridPosition);
             }
         }
 
         for (int i = 0; i < positionsWithOldChunks.Count; i++)
         {
             Vector3 worldPosition = new Vector3(positionsWithoutChunks[i].x * absoluteChunkSize, 0, positionsWithoutChunks[i].y * absoluteChunkSize);
             gridOfChunks[positionsWithOldChunks[i]].transform.position = worldPosition;
 
             // Recalculating noise for chunk based on its new position does lag more but even WITHOUT this it still stutters when player moves around. ( plan to learn threading just to calculate noise on seperate threads )
            // gridOfChunks[positionsWithOldChunks[i]].GetComponent<GEN_Chunk>().ApplyNoise();
         }
     }
 
     void GetAbsoluteChunkSize()
     {
         absoluteChunkSize = unitSize * chunkSize;
     }
 }