I need help with GL drawlines in unity

I have completed my whole project but after I built it I realized that Debug.Drawline doesn't show in the built project. I tried to rewrite the part of the code that printed the lines but I couldn't figure out how to use Gizmos and GL.

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
 public class OrbitPathFinder : MonoBehaviour
 {
     public int numSteps = 1000;
     public float timeStep = 0.1f;
     public float gravitationalConstant;
     public bool relativeToBody;
     public GameObject centralBody;
     private GameObject[] bodies;
     private bool gameOn = false;
     public Material mat;
     void Awake()
     {
         //DrawLineGL.CreateLinesGL();
     }
     void Update()
     {
         if(Input.GetKeyDown("space"))
         {
             gameOn = true;
         }
         if(gameOn)
         {
             HideOrbits();
         }
         else
         {
             DrawOrbits();
         }
     }
 
     void DrawOrbits()
     {
         bodies = GameObject.FindGameObjectsWithTag("Body");
         var virtualBodies = new VirtualBody[bodies.Length];
         var drawPoints = new Vector3[bodies.Length][];
         int referenceFrameIndex = 0;
         Vector3 referenceBodyInitialPosition = Vector3.zero;
 
         for (int i = 0;i < virtualBodies.Length;i++)
         {
             virtualBodies[i] = new VirtualBody (bodies[i]);
             drawPoints[i] = new Vector3[numSteps];
 
             if (bodies[i] == centralBody && relativeToBody) { 
                 referenceFrameIndex = i;                       
                 referenceBodyInitialPosition = virtualBodies[i].position; 
             }
         }
 
         for (int step = 0; step < numSteps; step++) {  //for each step simulate the virtual bodies
             Vector3 referenceBodyPosition = (relativeToBody) ? virtualBodies[referenceFrameIndex].position : Vector3.zero;//the position of the reference body in every step
             // Update velocities
             for (int i = 0; i < virtualBodies.Length; i++) {  //for each virtual body
                 virtualBodies[i].velocity += CalculateAcceleration (i, virtualBodies) * timeStep; //finds velocity of body at location
             }
             // Update positions
             for (int i = 0; i < virtualBodies.Length; i++) { //for each virtual object 
                 Vector3 newPos = virtualBodies[i].position + virtualBodies[i].velocity * timeStep; //new position is equal to the position and velocity times the time step
                 virtualBodies[i].position = newPos; //the virtual bodies position is then updated to the new position
                 if (relativeToBody) { //if there is a central body
                     var referenceFrameOffset = referenceBodyPosition - referenceBodyInitialPosition;// the offset of the reference frame is the new position - initialposition
                     newPos -= referenceFrameOffset; //the offset is then subtracted from the new position
                 }
                 if (relativeToBody && i == referenceFrameIndex) { //if relative to body and the reference frame is the current index
                     newPos = referenceBodyInitialPosition; //then the position will be the initalposition
                 }
 
                 drawPoints[i][step] = newPos; //The point where the line will be drawn has another value added
             }
         }                                   |
 //WHERE THE PROBLEM IS \/
         Shader shader = Shader.Find("Hidden/Internal-Colored");
         mat = new Material(shader);
         mat.hideFlags = HideFlags.HideAndDontSave;
         // Turn on alpha blending
         mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
         mat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
         // Turn backface culling off
         mat.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off);
         // Turn off depth writes
         mat.SetInt("_ZWrite", 0);
         mat.SetPass(0);
         GL.PushMatrix();
         GL.LoadOrtho();
         for (int bodyIndex = 0; bodyIndex < virtualBodies.Length; bodyIndex++) 
         {
                 var pathColour = bodies[bodyIndex].gameObject.GetComponent<TrailRenderer> ().sharedMaterial.color;
                     //sets the path to the colour of the object
                 GL.Begin(GL.LINES);
                 
                 for (int i = 0; i < drawPoints[bodyIndex].Length - 1; i++) { 
                     
                     GL.Vertex3(drawPoints[bodyIndex][i].x, drawPoints[bodyIndex][i].y, drawPoints[bodyIndex][i].z);
                     
                 var lineRenderer = bodies[bodyIndex].gameObject.GetComponentInChildren<LineRenderer> ();
                 if (lineRenderer) {
                     lineRenderer.enabled = false;  //disables the linerenderer in the child object of the planet
                 }
                 }
                 GL.End();
                 GL.PopMatrix();
 
         }
 
     }
 
     void HideOrbits()
     {
         for (int bodyIndex = 0; bodyIndex < bodies.Length; bodyIndex++) { //for each body
             var lineRenderer = bodies[bodyIndex].gameObject.GetComponentInChildren<LineRenderer> (); 
             lineRenderer.positionCount = 0; //sets the amount of positions to 0
         }
     }
 
     Vector3 CalculateAcceleration (int i, VirtualBody[] virtualBodies) {
         Vector3 acceleration = Vector3.zero;//acceleration = 0
         for (int j = 0; j < virtualBodies.Length; j++) {//foreach virtual body
             if (i == j) { //if the index of the virtual body is the same as the real objects then continue
                 continue;//    /\
             }       //         |
             Vector3 forceDir = (virtualBodies[j].position - virtualBodies[i].position).normalized;
             float sqrDst = (virtualBodies[j].position - virtualBodies[i].position).sqrMagnitude;
             acceleration += forceDir * gravitationalConstant * virtualBodies[j].mass / sqrDst;
         }   //find the acceleration of the vitual object at that point using gravity formula
         return acceleration;//return the value of the acceleration
     }
 
     class VirtualBody
     {
         public Vector3 position;
         public Vector3 velocity;
         public float mass;
 
         public VirtualBody(GameObject g)
         {
             position = g.transform.position;
             velocity = g.GetComponent<gravity>().startVelocity;
             mass = g.GetComponent<Rigidbody2D>().mass;
         }
     }
 }