C# OpenTK My viewport isn't displaying my model

I have tried to use GL.GetError() and it didn’t say anything. I wonder if this is my model code.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using OpenTK.Mathematics;
using OpenTK.Graphics.OpenGL4;
namespace opentk1pro
{
    internal class ObjMesh
    {
        private static int vbo;
        private static int vao;
        private static int size;
        struct BasicVertex
        {
            public Vector3 position;
            public Vector3 normal;
            public Vector2 uv;
        }
        public ObjMesh() { }

        public void Load(string fname)
        {
            string path = Handler.Convert(fname);
            if (!File.Exists(path))
            {
                Console.WriteLine("Unable to open \"" + path + "\", does not exist.");
                return;
            }
            List<Vector3> vertices;
            List<Vector2> textureVertices;
            List<Vector3> normals;
            List<int> vertexIndices;
            List<int> textureIndices;
            List<int> normalIndices;
            List<BasicVertex> basicVertices;
            basicVertices = new List<BasicVertex>();

            vertices = new List<Vector3>();
            textureVertices = new List<Vector2>();
            normals = new List<Vector3>();
            vertexIndices = new List<int>();
            textureIndices = new List<int>();
            normalIndices = new List<int>();

            using (StreamReader streamReader = new StreamReader(path))
            {
                while (!streamReader.EndOfStream)
                {
#pragma warning disable CS8602 // Dereference of a possibly null reference.
                    List<string> words = new List<string>(collection: streamReader.ReadLine().ToLower().Split(' '));
#pragma warning restore CS8602 // Dereference of a possibly null reference.
                    words.RemoveAll(s => s == string.Empty);

                    if (words.Count == 0)
                        continue;

                    string type = words[0];
                    words.RemoveAt(0);

                    switch (type)
                    {
                        // vertex
                        case "v":
                            vertices.Add(new Vector3(float.Parse(words[0]), float.Parse(words[1]),
                                                    float.Parse(words[2])));
                            break;

                        case "vt":
                            textureVertices.Add(new Vector2(float.Parse(words[0]), float.Parse(words[1])));
                            break;

                        case "vn":
                            normals.Add(new Vector3(float.Parse(words[0]), float.Parse(words[1]), float.Parse(words[2])));
                            break;

                        // face
                        case "f":
                            foreach (string w in words)
                            {
                                if (w.Length == 0)
                                    continue;

                                string[] comps = w.Split('/');

                                // subtract 1: indices start from 1, not 0
                                vertexIndices.Add(int.Parse(comps[0]) - 1);

                                if (comps.Length > 1 && comps[1].Length != 0)
                                    textureIndices.Add(int.Parse(comps[1]) - 1);

                                if (comps.Length > 2)
                                    normalIndices.Add(int.Parse(comps[2]) - 1);
                            }
                            break;

                        default:
                            break;
                    }
                }
            }
            BasicVertex basic = new BasicVertex();
            for (int i = 0;i < vertexIndices.Count; i++)
            {
                if (vertices.Count != 0)
                {
                    basic.position = vertices[vertexIndices[i]];
                }

                if (textureVertices.Count != 0)
                {
                    basic.uv = textureVertices[textureIndices[i]];
                }

                if (normals.Count != 0)
                {
                    basic.normal = normals[normalIndices[i]];
                }
                basicVertices.Add(basic);
            }
            vao = GL.GenVertexArray();
            GL.BindVertexArray(vao);

            vbo = GL.GenBuffer();
            GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
            
            GL.BufferData(BufferTarget.ArrayBuffer, basicVertices.Count * 8 * sizeof(float), basicVertices.ToArray(), BufferUsageHint.StaticDraw);

            GL.EnableVertexAttribArray(0);
            GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 8 * sizeof(float), 0);

            GL.EnableVertexAttribArray(1);
            GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, false, 8 * sizeof(float), 3 * sizeof(float));

            GL.EnableVertexAttribArray(2);
            GL.VertexAttribPointer(2, 3, VertexAttribPointerType.Float, false, 8 * sizeof(float), 3 * sizeof(float));
            
            size = vertexIndices.Count;
        }
        
        public void draw()
        {
            GL.BindVertexArray(vao);            
            GL.DrawArrays(PrimitiveType.Triangles, 0, size);
        }
    }
}

this is my renderer

using OpenTK.Mathematics;
using OpenTK.Windowing.Common;
using OpenTK.Windowing.Desktop;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using LearnOpenTK.Common;
using OpenTK.Windowing.GraphicsLibraryFramework;
using System.IO;
using OpenTK.Platform.Windows;
using OpenTK.Graphics.OpenGL4;
namespace opentk1pro
{
    internal class Rendering : GameWindow
    {
        private float lineStart = 0;

        private bool cap1 = false;
        private bool cap2 = true;

        private readonly float[] _vertices =
        {
            // Position         Texture coordinates
             1f,  1f, 0.0f, 1.0f, 1.0f, // top right
             1f, -1f, 0.0f, 1.0f, 0.0f, // bottom right
            -1f, -1f, 0.0f, 0.0f, 0.0f, // bottom left
            -1f,  1f, 0.0f, 0.0f, 1.0f  // top left
        };

        private readonly uint[] _indices =
        {
            0, 1, 3,
            1, 2, 3
        };

        private int _elementBufferObject;

        private int _vertexBufferObject;

        private int _vertexArrayObject;

        private float WindowWidth;
        private float WindowHeight;

        private ObjMesh? plane;

        private Camera _camera;

        private Texture? _texture;
        private Texture? plaTex;

        private ShaderProgram? aProgram;
        private ShaderProgram? ShipScreen;
        private ShaderProgram? test;
        public Rendering(int width = 1280, int height = 760, string title = "Game")
            : base(GameWindowSettings.Default, new NativeWindowSettings()
            {
                Title = title,
                ClientSize = new Vector2i(width, height),
                WindowBorder = WindowBorder.Fixed,
                StartVisible = false,
                StartFocused = true,
                API = ContextAPI.OpenGL,
                Profile = ContextProfile.Core,
                APIVersion = new Version(4, 3)
                
            })
        {
            this.CenterWindow(new Vector2i(1280, 768));
            this.UpdateFrequency = 60.0;
        }

        protected override void OnResize(ResizeEventArgs e)
        {
            GL.Viewport(0, 0, e.Width, e.Height);
            base.OnResize(e);
        }

        protected override void OnLoad()
        {
            this.IsVisible = true;
            GL.ClearColor(new Color4(.3f, .4f, .5f, 1.0f));
            GL.Enable(EnableCap.DepthTest);

            aProgram = new ShaderProgram("caption");
            ShipScreen = new ShaderProgram("ship");
            test = new ShaderProgram("test");

            _vertexArrayObject = GL.GenVertexArray();
            GL.BindVertexArray(_vertexArrayObject);

            _vertexBufferObject = GL.GenBuffer();
            GL.BindBuffer(BufferTarget.ArrayBuffer, _vertexBufferObject);
            GL.BufferData(BufferTarget.ArrayBuffer, _vertices.Length * sizeof(float), _vertices, BufferUsageHint.StaticDraw);

            _elementBufferObject = GL.GenBuffer();
            GL.BindBuffer(BufferTarget.ElementArrayBuffer, _elementBufferObject);
            GL.BufferData(BufferTarget.ElementArrayBuffer, _indices.Length * sizeof(uint), _indices, BufferUsageHint.StaticDraw);

            
                        
            GL.EnableVertexAttribArray(0);
            GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 5 * sizeof(float), 0);
            
            // Next, we also setup texture coordinates. It works in much the same way.
            // We add an offset of 3, since the texture coordinates comes after the position data.
            // We also change the amount of data to 2 because there's only 2 floats for texture coordinates.
            
            GL.EnableVertexAttribArray(1);
            GL.VertexAttribPointer(1, 2, VertexAttribPointerType.Float, false, 5 * sizeof(float), 3 * sizeof(float));           

            _texture = Texture.LoadFromFile("Textures/caption.png");            

            plaTex = Texture.LoadFromFile("Textures/ArrowTex.png");

            WindowWidth = (float)1280;
            WindowHeight = (float)760;

            _camera = new Camera(Vector3.UnitZ * 3, WindowWidth / WindowHeight);

            plane = new ObjMesh();
            plane.Load("Models/plane.obj");

            Handler.initTime();            

            base.OnLoad();
        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            double deltaTime = Handler.GetDelta();
            
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            if (cap1)
            {
                aProgram.use();
                aProgram.SetInt("texture0", 0);
                aProgram.SetFloat("lineStart", lineStart);
                _texture.Bind(0);

                GL.BindVertexArray(_vertexArrayObject);

                GL.DrawElements(PrimitiveType.Triangles, _indices.Length, DrawElementsType.UnsignedInt, 0);
            }
            else
            {
                
                Matrix4 projection = Matrix4.CreatePerspectiveFieldOfView(Handler.Degrees(45.0f), WindowWidth / WindowHeight, 0.01f, 100f);
                Matrix4 view = _camera.GetViewMatrix();
                
                Matrix4 model = Matrix4.Identity * Matrix4.CreateRotationX(Handler.Degrees(30));

                test.use();
                test.SetInt("Texture1", 0);
                test.SetMatrix4("model", model);
                test.SetMatrix4("view", view);
                test.SetMatrix4("projection", projection);

                plaTex.Bind(0);
                plane.draw();
                plaTex.UnBind(0);

                var error = GL.GetError();

                
            }
            

            

            lineStart += (float)(deltaTime * .25);
            if (lineStart > 1) lineStart = 0;

            SwapBuffers();

            base.OnRenderFrame(e);
        }

        protected override void OnUpdateFrame(FrameEventArgs e)
        {
            base.OnUpdateFrame(e);

            var input = KeyboardState;

            if (input.IsKeyDown(Keys.Escape))
            {
                Close();
            }
        }

        protected override void OnUnload()
        {
            GL.BindVertexArray(0);
            GL.DeleteVertexArray(_vertexArrayObject);
            GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
            GL.DeleteBuffer(_elementBufferObject);
            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
            GL.DeleteBuffer(_vertexBufferObject);
            
            base.OnUnload();
        }
    }
}

I have tried all kinds of translations for my model.

with cap1 = true it will display something