diff --git a/build.gradle b/build.gradle
index 006b7d5..ec8332a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,10 +1,10 @@
 plugins {
-    id 'fabric-loom' version '0.12-SNAPSHOT'
+    id 'fabric-loom' version '1.7-SNAPSHOT'
     id 'maven-publish'
 }
 
-sourceCompatibility = JavaVersion.VERSION_17
-targetCompatibility = JavaVersion.VERSION_17
+sourceCompatibility = JavaVersion.VERSION_21
+targetCompatibility = JavaVersion.VERSION_21
 
 archivesBaseName = project.archives_base_name
 version = project.mod_version
diff --git a/gradle.properties b/gradle.properties
index abcccdb..457fab3 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,21 +1,18 @@
 # Done to increase the memory available to gradle.
 org.gradle.jvmargs=-Xmx1G
 
-# Fabric Properties
-# check these on https://fabricmc.net/versions.html
-# After making changes
-# gradlew --refresh-dependencies
-# To remap the mixin locations:
-# gradlew migrateMappings --mappings "1.16.1+build.9"
-
-minecraft_version=1.19
-yarn_mappings=1.19+build.1
-loader_version=0.14.7
+minecraft_version=1.21
+yarn_mappings=1.21+build.9
+loader_version=0.16.2
 
 #Fabric api
-fabric_version=0.55.3+1.19
-
+fabric_version=0.102.0+1.21
 # Mod Properties
-mod_version = 1.19-fabric-1
+
+
+# Dependencies
+# check this on https://modmuss50.me/fabric.html
+mod_version = 1.21.01
+
 maven_group = net.torocraft
 archives_base_name = flighthud
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 8a17ae4..824aa8b 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https://services.gradle.org/distributions/gradle-7.3.1-bin.zip
+distributionUrl=https://services.gradle.org/distributions/gradle-8.8-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/src/main/java/net/torocraft/flighthud/Dimensions.java b/src/main/java/net/torocraft/flighthud/Dimensions.java
index 73b4d41..7ea5399 100644
--- a/src/main/java/net/torocraft/flighthud/Dimensions.java
+++ b/src/main/java/net/torocraft/flighthud/Dimensions.java
@@ -3,11 +3,13 @@
 import net.minecraft.client.MinecraftClient;
 import net.torocraft.flighthud.config.HudConfig;
 
+import java.lang.Math;
+
 public class Dimensions {
 
   public float hScreen;
   public float wScreen;
-  public float degreesPerPixel;
+  public float pixelsPerDegree;
   public float xMid;
   public float yMid;
 
@@ -31,7 +33,30 @@ public void update(MinecraftClient client) {
       wScreen = wScreen * c.scale;
     }
 
-    degreesPerPixel = hScreen / client.options.getFov().getValue();
+    // The HUD is rendered as a plane in front of the player and not at a
+    // spehere. The pixelsPerDegree parameter is therefore a simplification,
+    // which is not exact.
+    //
+    // To use this simplification, a given spot on the screen has to be picked
+    // to be be correct for the approximation.
+    //
+    // Most intuitive would then be to have the horizon line correctly stick to
+    // the world when in the center of the screen. So therefore, calculate the
+    // number of degrees per pixel in the _center_ of the screen
+    //
+    // This simplifies rendering a lot, instead of always calculate the correct
+    // transformation between spherical and cartesian coordinates
+
+
+    // Calculate height of virtual screen at distance of 1 unit
+    // Note that FOV is degrees from top to bottom, we need height from center
+    // to top
+
+    Integer fov_deg = client.options.getFov().getValue();
+    double hud_height = Math.tan(fov_deg * Math.PI / 180.0 / 2.0);
+    double hud_pixel_height = hud_height / (double)(hScreen/2);
+    pixelsPerDegree = 1.0f / (float)(Math.atan(hud_pixel_height) * 180.0 / Math.PI);
+
     xMid = wScreen / 2;
     yMid = hScreen / 2;
 
@@ -45,4 +70,4 @@ public void update(MinecraftClient client) {
     bFrame = tFrame + hFrame;
   }
 
-}
\ No newline at end of file
+}
diff --git a/src/main/java/net/torocraft/flighthud/FlightComputer.java b/src/main/java/net/torocraft/flighthud/FlightComputer.java
index de26854..e45bfa7 100644
--- a/src/main/java/net/torocraft/flighthud/FlightComputer.java
+++ b/src/main/java/net/torocraft/flighthud/FlightComputer.java
@@ -7,13 +7,13 @@
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
+import org.joml.Quaternionf;
+import org.joml.Vector3f;
 
 public class FlightComputer {
   private static final float TICKS_PER_SECOND = 20;
-
-  private float previousRollAngle = 0.0f;
+  static final float rad2deg = (float)(180/Math.PI);
 
   public Vec3d velocity;
   public float speed;
@@ -28,12 +28,52 @@ public class FlightComputer {
   public Float distanceFromGround;
   public Float elytraHealth;
 
-  public void update(MinecraftClient client, float partial) {
+  public static Vector3f quaternionToEuler(Quaternionf q) {
+    /**
+      * Roll logic is from:
+      * https://github.com/HuJK/FlightHUD-Do-a-Barrel-Roll-Fix/blob/dabr-1.20.5/src/main/java/net/torocraft/flighthud/FlightComputer.java#L32
+      * it retrive rotation quaternion from camara to enable both mods will sync up when used together.
+    */
+    double x = q.x;
+    double y = q.y;
+    double z = q.z;
+    double w = q.w;
+
+    double yaw, pitch, roll;
+
+    // Yaw (Y-axis rotation)
+    double sinr_cosp = 2 * (w * y + x * z);
+    double cosr_cosp = 1 - 2 * (y * y + x * x);
+    yaw = Math.atan2(sinr_cosp, cosr_cosp);
+
+    // Pitch (X-axis rotation)
+    double sinp = 2 * (w * x - z * y);
+    if (Math.abs(sinp) >= 1)
+        pitch = Math.copySign(Math.PI / 2, sinp); // use 90 degrees if out of range
+    else
+        pitch = Math.asin(sinp);
+
+    // Roll (Z-axis rotation)
+    double siny_cosp = 2 * (w * z + y * x);
+    double cosy_cosp = 1 - 2 * (x * x + z * z);
+    roll = Math.atan2(siny_cosp, cosy_cosp);
+
+    return new Vector3f((float) yaw, (float) pitch, (float) roll);
+  }
+
+  public void update(MinecraftClient client, Quaternionf rotation) {
+    if (client==null){
+      return;
+    }
+    Vector3f eulerrotation = quaternionToEuler(rotation);
+    heading = -eulerrotation.x* rad2deg;
+    pitch = eulerrotation.y* rad2deg;
+    roll = eulerrotation.z* rad2deg;
+    //heading =  computeHeading(client);
+    //pitch =  computePitch(client);
+    //roll = computeRoll(client, eulerrotation.z* rad2deg);
     velocity = client.player.getVelocity();
-    pitch = computePitch(client, partial);
     speed = computeSpeed(client);
-    roll = computeRoll(client, partial);
-    heading = computeHeading(client);
     altitude = computeAltitude(client);
     groundLevel = computeGroundLevel(client);
     distanceFromGround = computeDistanceFromGround(client, altitude, groundLevel);
@@ -71,36 +111,20 @@ private float computeFlightHeading(Vec3d velocity, float heading) {
    * https://github.com/Jorbon/cool_elytra/blob/main/src/main/java/edu/jorbonism/cool_elytra/mixin/GameRendererMixin.java
    * to enable both mods will sync up when used together.
    */
-  private float computeRoll(MinecraftClient client, float partial) {
+  private float computeRoll(MinecraftClient client, float roll) {
     if (!FlightHud.CONFIG_SETTINGS.calculateRoll) {
-      return 0;
-    }
-
-    float wingPower = FlightHud.CONFIG_SETTINGS.rollTurningForce;
-    float rollSmoothing = FlightHud.CONFIG_SETTINGS.rollSmoothing;
-    Vec3d facing = client.player.getRotationVecClient();
-    Vec3d velocity = client.player.getVelocity();
-    double horizontalFacing2 = facing.horizontalLengthSquared();
-    double horizontalSpeed2 = velocity.horizontalLengthSquared();
-
-    float rollAngle = 0.0f;
-
-    if (horizontalFacing2 > 0.0D && horizontalSpeed2 > 0.0D) {
-      double dot = (velocity.x * facing.x + velocity.z * facing.z) / Math.sqrt(horizontalFacing2 * horizontalSpeed2);
-      dot = MathHelper.clamp(dot, -1, 1);
-      double direction = Math.signum(velocity.x * facing.z - velocity.z * facing.x);
-      rollAngle = (float) (Math.atan(Math.sqrt(horizontalSpeed2) * Math.acos(dot) * wingPower) * direction
-          * 57.29577951308);
+      return 0.0f;
     }
 
-    rollAngle = (float) ((1.0 - rollSmoothing) * rollAngle + rollSmoothing * previousRollAngle);
-    previousRollAngle = rollAngle;
-
-    return rollAngle;
+    return roll;
   }
 
-  private float computePitch(MinecraftClient client, float parital) {
-    return client.player.getPitch(parital) * -1;
+  private float computePitch(MinecraftClient client) {
+    if (client.player == null) {
+      return 0.0f;
+    }
+
+    return -client.player.getPitch();
   }
 
   private boolean isGround(BlockPos pos, MinecraftClient client) {
@@ -137,6 +161,10 @@ private float computeAltitude(MinecraftClient client) {
   }
 
   private float computeHeading(MinecraftClient client) {
+    if (client.player == null) {
+      return 0.0f;
+    }
+
     return toHeading(client.player.getYaw());
   }
 
diff --git a/src/main/java/net/torocraft/flighthud/FlightHud.java b/src/main/java/net/torocraft/flighthud/FlightHud.java
index f64076a..70c7d23 100644
--- a/src/main/java/net/torocraft/flighthud/FlightHud.java
+++ b/src/main/java/net/torocraft/flighthud/FlightHud.java
@@ -38,6 +38,8 @@ public class FlightHud implements ClientModInitializer {
 
   private static KeyBinding keyBinding;
 
+  public static final FlightComputer computer = new FlightComputer();
+
   @Override
   public void onInitializeClient() {
     CONFIG_LOADER_SETTINGS.load();
diff --git a/src/main/java/net/torocraft/flighthud/HudComponent.java b/src/main/java/net/torocraft/flighthud/HudComponent.java
index 08be596..94e41c3 100644
--- a/src/main/java/net/torocraft/flighthud/HudComponent.java
+++ b/src/main/java/net/torocraft/flighthud/HudComponent.java
@@ -2,21 +2,15 @@
 
 import com.mojang.blaze3d.systems.RenderSystem;
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.gui.DrawableHelper;
-import net.minecraft.client.render.BufferBuilder;
-import net.minecraft.client.render.BufferRenderer;
-import net.minecraft.client.render.GameRenderer;
-import net.minecraft.client.render.Tessellator;
-import net.minecraft.client.render.VertexFormats;
-import net.minecraft.client.render.VertexFormat;
+import net.minecraft.client.gui.DrawContext;
+import net.minecraft.client.render.*;
 import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.util.math.Vec3f;
-import net.minecraft.util.math.Matrix4f;
 import net.torocraft.flighthud.config.HudConfig;
+import org.joml.Matrix4f;
 
-public abstract class HudComponent extends DrawableHelper {
+public abstract class HudComponent{
 
-  public abstract void render(MatrixStack m, float partial, MinecraftClient client);
+  public abstract void render(DrawContext context, float partial, MinecraftClient client);
 
   public static HudConfig CONFIG;
 
@@ -24,13 +18,15 @@ protected int i(double d) {
     return (int) Math.round(d);
   }
 
-  protected void drawPointer(MatrixStack m, float x, float y, float rot) {
-    m.push();
-    m.translate(x, y, 0);
-    m.multiply(Vec3f.POSITIVE_Z.getDegreesQuaternion(rot + 45));
-    drawVerticalLine(m, 0, 0, 5, CONFIG.color);
-    drawHorizontalLine(m, 0, 5, 0, CONFIG.color);
-    m.pop();
+  protected void drawPointer(DrawContext context, float x, float y, float rot) {
+    MatrixStack matrixes = context.getMatrices();
+    matrixes.push();
+    matrixes.translate(x, y, 0);
+//    m.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion(rot + 45));
+    matrixes.multiply(new org.joml.Quaternionf().fromAxisAngleDeg(new org.joml.Vector3f(0, 0, 1),rot+45));
+    drawVerticalLine(context, 0, 0, 5);//, CONFIG.color
+    drawHorizontalLine(context, 0, 5, 0);//, CONFIG.color
+    matrixes.pop();
   }
 
   protected float wrapHeading(float degrees) {
@@ -41,29 +37,28 @@ protected float wrapHeading(float degrees) {
     return degrees;
   }
 
-  protected void drawFont(MinecraftClient mc, MatrixStack m, String s, float x, float y) {
-    drawFont(mc, m, s, x, y, CONFIG.color);
+  protected void drawFont(MinecraftClient mc, DrawContext context, String text, float x, float y) {
+    drawFont(mc, context, text, x, y, CONFIG.color);
   }
 
-  protected void drawFont(MinecraftClient mc, MatrixStack m, String s, float x, float y,
-      int color) {
-    mc.textRenderer.draw(m, s, x, y, CONFIG.color);
+  protected void drawFont(MinecraftClient mc, DrawContext context, String text, float x, float y, int color) {
+    context.drawText(mc.textRenderer, text, (int)x, (int)y, color, false);
   }
 
-  protected void drawRightAlignedFont(MinecraftClient mc, MatrixStack m, String s, float x,
+  protected void drawRightAlignedFont(MinecraftClient mc, DrawContext context, String s, float x,
       float y) {
     int w = mc.textRenderer.getWidth(s);
-    drawFont(mc, m, s, x - w, y);
+    drawFont(mc, context, s, x - w, y);
   }
 
-  protected void drawBox(MatrixStack m, float x, float y, float w, float h) {
-    drawHorizontalLine(m, x, x + w, y);
-    drawHorizontalLine(m, x, x + w, y + h);
-    drawVerticalLine(m, x, y, y + h);
-    drawVerticalLine(m, x + w, y, y + h);
+  protected void drawBox(DrawContext context, float x, float y, float w, float h) {
+    drawHorizontalLine(context, x, x + w, y);
+    drawHorizontalLine(context, x, x + w, y + h);
+    drawVerticalLine(context, x, y, y + h);
+    drawVerticalLine(context, x + w, y, y + h);
   }
 
-  protected void drawHorizontalLineDashed(MatrixStack m, float x1, float x2, float y,
+  protected void drawHorizontalLineDashed(DrawContext context, float x1, float x2, float y,
       int dashCount) {
     float width = x2 - x1;
     int segmentCount = dashCount * 2 - 1;
@@ -79,33 +74,34 @@ protected void drawHorizontalLineDashed(MatrixStack m, float x1, float x2, float
       } else {
         dx2 = ((i + 1) * dashSize) + x1;
       }
-      drawHorizontalLine(m, dx1, dx2, y);
+      drawHorizontalLine(context, dx1, dx2, y);
     }
   }
 
-  protected void drawHorizontalLine(MatrixStack matrices, float x1, float x2, float y) {
+  protected void drawHorizontalLine(DrawContext context, float x1, float x2, float y) {
     if (x2 < x1) {
       float i = x1;
       x1 = x2;
       x2 = i;
     }
-    fill(matrices, x1 - CONFIG.halfThickness, y - CONFIG.halfThickness, x2 + CONFIG.halfThickness,
+    fill(context, x1 - CONFIG.halfThickness, y - CONFIG.halfThickness, x2 + CONFIG.halfThickness,
         y + CONFIG.halfThickness);
   }
 
-  protected void drawVerticalLine(MatrixStack matrices, float x, float y1, float y2) {
+  protected void drawVerticalLine(DrawContext context, float x, float y1, float y2) {
     if (y2 < y1) {
       float i = y1;
       y1 = y2;
       y2 = i;
     }
 
-    fill(matrices, x - CONFIG.halfThickness, y1 + CONFIG.halfThickness, x + CONFIG.halfThickness,
+    fill(context, x - CONFIG.halfThickness, y1 + CONFIG.halfThickness, x + CONFIG.halfThickness,
         y2 - CONFIG.halfThickness);
   }
 
-  public static void fill(MatrixStack matrices, float x1, float y1, float x2, float y2) {
-    fill(matrices.peek().getPositionMatrix(), x1, y1, x2, y2);
+  public static void fill(DrawContext context, float x1, float y1, float x2, float y2) {
+    MatrixStack matrixes = context.getMatrices();
+    fill(matrixes.peek().getPositionMatrix(), x1, y1, x2, y2);
   }
 
   private static void fill(Matrix4f matrix, float x1, float y1, float x2, float y2) {
@@ -127,18 +123,19 @@ private static void fill(Matrix4f matrix, float x1, float y1, float x2, float y2
     float r = (float) (color >> 16 & 255) / 255.0F;
     float g = (float) (color >> 8 & 255) / 255.0F;
     float b = (float) (color & 255) / 255.0F;
-    BufferBuilder bufferBuilder = Tessellator.getInstance().getBuffer();
     RenderSystem.enableBlend();
-    RenderSystem.disableTexture();
+//    RenderSystem.disableTexture();
     RenderSystem.defaultBlendFunc();
-    RenderSystem.setShader(GameRenderer::getPositionColorShader);
-    bufferBuilder.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_COLOR);
-    bufferBuilder.vertex(matrix, x1, y2, 0.0F).color(r, g, b, alpha).next();
-    bufferBuilder.vertex(matrix, x2, y2, 0.0F).color(r, g, b, alpha).next();
-    bufferBuilder.vertex(matrix, x2, y1, 0.0F).color(r, g, b, alpha).next();
-    bufferBuilder.vertex(matrix, x1, y1, 0.0F).color(r, g, b, alpha).next();
-    BufferRenderer.drawWithShader(bufferBuilder.end());
-    RenderSystem.enableTexture();
+//    RenderSystem.setShader(GameRenderer::getPositionColorShader);
+    RenderSystem.setShader(GameRenderer::getPositionColorProgram);
+    BufferBuilder bufferBuilder = Tessellator.getInstance().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_COLOR);
+    bufferBuilder.vertex(matrix, x1, y2, 0.0F).color(r, g, b, alpha);
+    bufferBuilder.vertex(matrix, x2, y2, 0.0F).color(r, g, b, alpha);
+    bufferBuilder.vertex(matrix, x2, y1, 0.0F).color(r, g, b, alpha);
+    bufferBuilder.vertex(matrix, x1, y1, 0.0F).color(r, g, b, alpha);
+//    BufferRenderer.drawWithShader(bufferBuilder.end());
+    BufferRenderer.drawWithGlobalProgram(bufferBuilder.end());
+//    RenderSystem.enableTexture();
     RenderSystem.disableBlend();
   }
 }
diff --git a/src/main/java/net/torocraft/flighthud/HudRenderer.java b/src/main/java/net/torocraft/flighthud/HudRenderer.java
index aceaebc..aa935d3 100644
--- a/src/main/java/net/torocraft/flighthud/HudRenderer.java
+++ b/src/main/java/net/torocraft/flighthud/HudRenderer.java
@@ -1,6 +1,7 @@
 package net.torocraft.flighthud;
 
 import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.DrawContext;
 import net.minecraft.client.util.math.MatrixStack;
 import net.torocraft.flighthud.components.AltitudeIndicator;
 import net.torocraft.flighthud.components.ElytraHealthIndicator;
@@ -10,11 +11,11 @@
 import net.torocraft.flighthud.components.PitchIndicator;
 import net.torocraft.flighthud.components.SpeedIndicator;
 import net.torocraft.flighthud.config.SettingsConfig.DisplayMode;
+import static net.torocraft.flighthud.FlightHud.computer;
 
 public class HudRenderer extends HudComponent {
 
   private final Dimensions dim = new Dimensions();
-  private final FlightComputer computer = new FlightComputer();
   private static final String FULL = DisplayMode.FULL.toString();
   private static final String MIN = DisplayMode.MIN.toString();
 
@@ -42,8 +43,9 @@ private void setupConfig(MinecraftClient client) {
   }
 
   @Override
-  public void render(MatrixStack m, float partial, MinecraftClient client) {
+  public void render(DrawContext context, float partial, MinecraftClient client) {
     setupConfig(client);
+    MatrixStack m = context.getMatrices();
 
     if (HudComponent.CONFIG == null) {
       return;
@@ -53,15 +55,14 @@ public void render(MatrixStack m, float partial, MinecraftClient client) {
       m.push();
 
       if (HudComponent.CONFIG.scale != 1d) {
-        float scale = 1 / (float) HudComponent.CONFIG.scale;
+        float scale = 1 / HudComponent.CONFIG.scale;
         m.scale(scale, scale, scale);
       }
 
-      computer.update(client, partial);
       dim.update(client);
 
       for (HudComponent component : components) {
-        component.render(m, partial, client);
+        component.render(context, partial, client);
       }
       m.pop();
     } catch (Exception e) {
diff --git a/src/main/java/net/torocraft/flighthud/components/AltitudeIndicator.java b/src/main/java/net/torocraft/flighthud/components/AltitudeIndicator.java
index efb8cdf..34e607d 100644
--- a/src/main/java/net/torocraft/flighthud/components/AltitudeIndicator.java
+++ b/src/main/java/net/torocraft/flighthud/components/AltitudeIndicator.java
@@ -1,10 +1,10 @@
 package net.torocraft.flighthud.components;
 
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.util.math.MatrixStack;
 import net.torocraft.flighthud.Dimensions;
 import net.torocraft.flighthud.FlightComputer;
 import net.torocraft.flighthud.HudComponent;
+import net.minecraft.client.gui.DrawContext;
 
 public class AltitudeIndicator extends HudComponent {
   private final Dimensions dim;
@@ -16,7 +16,7 @@ public AltitudeIndicator(FlightComputer computer, Dimensions dim) {
   }
 
   @Override
-  public void render(MatrixStack m, float partial, MinecraftClient mc) {
+  public void render(DrawContext context, float partial, MinecraftClient mc) {
     float top = dim.tFrame;
     float bottom = dim.bFrame;
 
@@ -30,20 +30,20 @@ public void render(MatrixStack m, float partial, MinecraftClient mc) {
     float xAltText = right + 5;
 
     if (CONFIG.altitude_showGroundInfo) {
-      drawHeightIndicator(mc, m, left - 1, dim.yMid, bottom - dim.yMid);
+      drawHeightIndicator(mc, context, left - 1, dim.yMid, bottom - dim.yMid);
     }
 
     if (CONFIG.altitude_showReadout) {
-      drawFont(mc, m, String.format("%.0f", computer.altitude), xAltText, dim.yMid - 3);
-      drawBox(m, xAltText - 2, dim.yMid - 4.5f, 28, 10);
+      drawFont(mc, context, String.format("%.0f", computer.altitude), xAltText, dim.yMid - 3);
+      drawBox(context, xAltText - 2, dim.yMid - 4.5f, 28, 10);
     }
 
     if (CONFIG.altitude_showHeight) {
-      drawFont(mc, m, "G", xAltText - 10, bottom + 3);
+      drawFont(mc, context, "G", xAltText - 10, bottom + 3);
       String heightText = computer.distanceFromGround == null ? "??"
           : String.format("%d", i(computer.distanceFromGround));
-      drawFont(mc, m, heightText, xAltText, bottom + 3);
-      drawBox(m, xAltText - 2, bottom + 1.5f, 28, 10);
+      drawFont(mc, context, heightText, xAltText, bottom + 3);
+      drawBox(context, xAltText - 2, bottom + 1.5f, 28, 10);
     }
 
     if (CONFIG.altitude_showScale) {
@@ -54,34 +54,34 @@ public void render(MatrixStack m, float partial, MinecraftClient mc) {
           continue;
 
         if (i % 50 == 0) {
-          drawHorizontalLine(m, left, right + 2, y);
+          drawHorizontalLine(context, left, right + 2, y);
           if (!CONFIG.altitude_showReadout || y > dim.yMid + 7 || y < dim.yMid - 7) {
-            drawFont(mc, m, String.format("%d", i), xAltText, y - 3);
+            drawFont(mc, context, String.format("%d", i), xAltText, y - 3);
           }
         }
-        drawHorizontalLine(m, left, right, y);
+        drawHorizontalLine(context, left, right, y);
       }
     }
   }
 
-  private void drawHeightIndicator(MinecraftClient client, MatrixStack m, float x, float top, float h) {
+  private void drawHeightIndicator(MinecraftClient client, DrawContext context, float x, float top, float h) {
     float bottom = top + h;
     float blocksPerPixel =  h / (client.world.getHeight() + 64f);
     float yAlt = bottom - i((computer.altitude + 64) * blocksPerPixel);
     float yFloor = bottom - i(64 * blocksPerPixel);
 
-    drawVerticalLine(m, x, top - 1, bottom + 1);
+    drawVerticalLine(context, x, top - 1, bottom + 1);
 
     if (computer.groundLevel != null) {
       float yGroundLevel = bottom - (computer.groundLevel + 64f) * blocksPerPixel;
-      fill(m, x - 3, yGroundLevel + 2, x, yFloor);
+      fill(context, x - 3, yGroundLevel + 2, x, yFloor);
     }
 
-    drawHorizontalLine(m, x - 6, x - 1, top);
-    drawHorizontalLine(m, x - 6, x - 1, yFloor);
-    drawHorizontalLine(m, x - 6, x - 1, bottom);
+    drawHorizontalLine(context, x - 6, x - 1, top);
+    drawHorizontalLine(context, x - 6, x - 1, yFloor);
+    drawHorizontalLine(context, x - 6, x - 1, bottom);
 
-    drawPointer(m, x, yAlt, 90);
+    drawPointer(context, x, yAlt, 90);
   }
 
 }
diff --git a/src/main/java/net/torocraft/flighthud/components/ElytraHealthIndicator.java b/src/main/java/net/torocraft/flighthud/components/ElytraHealthIndicator.java
index f1d3722..a9630fb 100644
--- a/src/main/java/net/torocraft/flighthud/components/ElytraHealthIndicator.java
+++ b/src/main/java/net/torocraft/flighthud/components/ElytraHealthIndicator.java
@@ -1,10 +1,10 @@
 package net.torocraft.flighthud.components;
 
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.util.math.MatrixStack;
 import net.torocraft.flighthud.Dimensions;
 import net.torocraft.flighthud.FlightComputer;
 import net.torocraft.flighthud.HudComponent;
+import net.minecraft.client.gui.DrawContext;
 
 public class ElytraHealthIndicator extends HudComponent {
 
@@ -17,7 +17,7 @@ public ElytraHealthIndicator(FlightComputer computer, Dimensions dim) {
   }
 
   @Override
-  public void render(MatrixStack m, float partial, MinecraftClient mc) {
+  public void render(DrawContext context, float partial, MinecraftClient mc) {
     if (!CONFIG.elytra_showHealth || computer.elytraHealth == null) {
       return;
     }
@@ -25,8 +25,8 @@ public void render(MatrixStack m, float partial, MinecraftClient mc) {
     float x = dim.wScreen * CONFIG.elytra_x;
     float y = dim.hScreen * CONFIG.elytra_y;
 
-    drawBox(m, x - 3.5f, y - 1.5f, 30, 10);
-    drawFont(mc, m, "E", x - 10, y);
-    drawFont(mc, m, String.format("%d", i(computer.elytraHealth)) + "%", x, y);
+    drawBox(context, x - 3.5f, y - 1.5f, 30, 10);
+    drawFont(mc, context, "E", x - 10, y);
+    drawFont(mc, context, String.format("%d", i(computer.elytraHealth)) + "%", x, y);
   }
 }
\ No newline at end of file
diff --git a/src/main/java/net/torocraft/flighthud/components/FlightPathIndicator.java b/src/main/java/net/torocraft/flighthud/components/FlightPathIndicator.java
index 985ad0a..3779caa 100644
--- a/src/main/java/net/torocraft/flighthud/components/FlightPathIndicator.java
+++ b/src/main/java/net/torocraft/flighthud/components/FlightPathIndicator.java
@@ -1,10 +1,10 @@
 package net.torocraft.flighthud.components;
 
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.util.math.MatrixStack;
 import net.torocraft.flighthud.Dimensions;
 import net.torocraft.flighthud.FlightComputer;
 import net.torocraft.flighthud.HudComponent;
+import net.minecraft.client.gui.DrawContext;
 
 public class FlightPathIndicator extends HudComponent {
   private final Dimensions dim;
@@ -16,7 +16,7 @@ public FlightPathIndicator(FlightComputer computer, Dimensions dim) {
   }
 
   @Override
-  public void render(MatrixStack m, float partial, MinecraftClient client) {
+  public void render(DrawContext context, float partial, MinecraftClient client) {
     if (!CONFIG.flightPath_show) {
       return;
     }
@@ -31,8 +31,9 @@ public void render(MatrixStack m, float partial, MinecraftClient client) {
     float y = dim.yMid;
     float x = dim.xMid;
 
-    y += i(deltaPitch * dim.degreesPerPixel);
-    x += i(deltaHeading * dim.degreesPerPixel);
+    y += i(deltaPitch * dim.pixelsPerDegree);
+    // Subtract X, so the flight path indicator moves into the turn when turning
+    x -= i(deltaHeading * dim.pixelsPerDegree);
 
     if (y < dim.tFrame || y > dim.bFrame || x < dim.lFrame || x > dim.rFrame) {
       return;
@@ -43,14 +44,14 @@ public void render(MatrixStack m, float partial, MinecraftClient client) {
     float t = y - 3 - CONFIG.halfThickness;
     float b = y + 3 - CONFIG.halfThickness;
 
-    drawVerticalLine(m, l, t, b);
-    drawVerticalLine(m, r, t, b);
+    drawVerticalLine(context, l, t, b);
+    drawVerticalLine(context, r, t, b);
 
-    drawHorizontalLine(m, l, r, t);
-    drawHorizontalLine(m, l, r, b);
+    drawHorizontalLine(context, l, r, t);
+    drawHorizontalLine(context, l, r, b);
 
-    drawVerticalLine(m, x, t - 5, t);
-    drawHorizontalLine(m, l - 4, l, y - CONFIG.halfThickness);
-    drawHorizontalLine(m, r, r + 4, y - CONFIG.halfThickness);
+    drawVerticalLine(context, x, t - 5, t);
+    drawHorizontalLine(context, l - 4, l, y - CONFIG.halfThickness);
+    drawHorizontalLine(context, r, r + 4, y - CONFIG.halfThickness);
   }
 }
diff --git a/src/main/java/net/torocraft/flighthud/components/HeadingIndicator.java b/src/main/java/net/torocraft/flighthud/components/HeadingIndicator.java
index a3acf8b..088ef2c 100644
--- a/src/main/java/net/torocraft/flighthud/components/HeadingIndicator.java
+++ b/src/main/java/net/torocraft/flighthud/components/HeadingIndicator.java
@@ -1,10 +1,10 @@
 package net.torocraft.flighthud.components;
 
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.util.math.MatrixStack;
 import net.torocraft.flighthud.Dimensions;
 import net.torocraft.flighthud.FlightComputer;
 import net.torocraft.flighthud.HudComponent;
+import net.minecraft.client.gui.DrawContext;
 
 public class HeadingIndicator extends HudComponent {
 
@@ -17,40 +17,40 @@ public HeadingIndicator(FlightComputer computer, Dimensions dim) {
   }
 
   @Override
-  public void render(MatrixStack m, float partial, MinecraftClient mc) {
+  public void render(DrawContext context, float partial, MinecraftClient mc) {
     float left = dim.lFrame;
     float right = dim.rFrame;
     float top = dim.tFrame - 10;
 
     float yText = top - 7;
-    float northOffset = computer.heading * dim.degreesPerPixel;
+    float northOffset = computer.heading * dim.pixelsPerDegree;
     float xNorth = dim.xMid - northOffset;
 
     if (CONFIG.heading_showReadout) {
-      drawFont(mc, m, String.format("%03d", i(wrapHeading(computer.heading))), dim.xMid - 8, yText);
-      drawBox(m, dim.xMid - 15, yText - 1.5f, 30, 10);
+      drawFont(mc, context, String.format("%03d", i(wrapHeading(computer.heading))), dim.xMid - 8, yText);
+      drawBox(context, dim.xMid - 15, yText - 1.5f, 30, 10);
     }
 
     if (CONFIG.heading_showScale) {
-      drawPointer(m, dim.xMid, top + 10, 0);
+      drawPointer(context, dim.xMid, top + 10, 0);
       for (int i = -540; i < 540; i = i + 5) {
-        float x = (i * dim.degreesPerPixel) + xNorth;
+        float x = (i * dim.pixelsPerDegree) + xNorth;
         if (x < left || x > right)
           continue;
 
         if (i % 15 == 0) {
           if (i % 90 == 0) {
-            drawFont(mc, m, headingToDirection(i), x - 2, yText + 10);
-            drawFont(mc, m, headingToAxis(i), x - 8, yText + 20);
+            drawFont(mc, context, headingToDirection(i), x - 2, yText + 10);
+            drawFont(mc, context, headingToAxis(i), x - 8, yText + 20);
           } else {
-            drawVerticalLine(m, x, top + 3, top + 10);
+            drawVerticalLine(context, x, top + 3, top + 10);
           }
 
           if (!CONFIG.heading_showReadout || x <= dim.xMid - 26 || x >= dim.xMid + 26) {
-            drawFont(mc, m, String.format("%03d", i(wrapHeading(i))), x - 8, yText);
+            drawFont(mc, context, String.format("%03d", i(wrapHeading(i))), x - 8, yText);
           }
         } else {
-          drawVerticalLine(m, x, top + 6, top + 10);
+          drawVerticalLine(context, x, top + 6, top + 10);
         }
       }
     }
diff --git a/src/main/java/net/torocraft/flighthud/components/LocationIndicator.java b/src/main/java/net/torocraft/flighthud/components/LocationIndicator.java
index 9c6075f..d2767ba 100644
--- a/src/main/java/net/torocraft/flighthud/components/LocationIndicator.java
+++ b/src/main/java/net/torocraft/flighthud/components/LocationIndicator.java
@@ -1,9 +1,9 @@
 package net.torocraft.flighthud.components;
 
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.util.math.MatrixStack;
 import net.torocraft.flighthud.Dimensions;
 import net.torocraft.flighthud.HudComponent;
+import net.minecraft.client.gui.DrawContext;
 
 public class LocationIndicator extends HudComponent {
 
@@ -14,7 +14,7 @@ public LocationIndicator(Dimensions dim) {
   }
 
   @Override
-  public void render(MatrixStack m, float partial, MinecraftClient mc) {
+  public void render(DrawContext context, float partial, MinecraftClient mc) {
     if (!CONFIG.location_showReadout) {
       return;
     }
@@ -25,6 +25,6 @@ public void render(MatrixStack m, float partial, MinecraftClient mc) {
     int xLoc = mc.player.getBlockPos().getX();
     int zLoc = mc.player.getBlockPos().getZ();
 
-    drawFont(mc, m, String.format("%d / %d", xLoc, zLoc), x, y);
+    drawFont(mc, context, String.format("%d / %d", xLoc, zLoc), x, y);
   }
 }
diff --git a/src/main/java/net/torocraft/flighthud/components/PitchIndicator.java b/src/main/java/net/torocraft/flighthud/components/PitchIndicator.java
index d75ea9e..477e378 100644
--- a/src/main/java/net/torocraft/flighthud/components/PitchIndicator.java
+++ b/src/main/java/net/torocraft/flighthud/components/PitchIndicator.java
@@ -2,10 +2,11 @@
 
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.util.math.Vec3f;
 import net.torocraft.flighthud.Dimensions;
 import net.torocraft.flighthud.FlightComputer;
 import net.torocraft.flighthud.HudComponent;
+import org.joml.Vector3f;
+import net.minecraft.client.gui.DrawContext;
 
 public class PitchIndicator extends HudComponent {
   private final Dimensions dim;
@@ -18,43 +19,44 @@ public PitchIndicator(FlightComputer computer, Dimensions dim) {
   }
 
   @Override
-  public void render(MatrixStack m, float partial, MinecraftClient mc) {
+  public void render(DrawContext context, float partial, MinecraftClient mc) {
     pitchData.update(dim);
 
-    float horizonOffset = computer.pitch * dim.degreesPerPixel;
+    float horizonOffset = computer.pitch * dim.pixelsPerDegree;
     float yHorizon = dim.yMid + horizonOffset;
 
     float a = dim.yMid;
     float b = dim.xMid;
 
     float roll = computer.roll * (CONFIG.pitchLadder_reverseRoll ? -1 : 1);
-
+    MatrixStack matrixes = context.getMatrices();
     if (CONFIG.pitchLadder_showRoll) {
-      m.push();
-      m.translate(b, a, 0);
-      m.multiply(Vec3f.POSITIVE_Z.getDegreesQuaternion(roll));
-      m.translate(-b, -a, 0);
+      matrixes.push();
+      matrixes.translate(b, a, 0);
+//      m.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion(roll));
+      matrixes.multiply(new org.joml.Quaternionf().fromAxisAngleDeg(new Vector3f(0, 0, 1),roll));
+      matrixes.translate(-b, -a, 0);
     }
 
     if (CONFIG.pitchLadder_showLadder) {
-      drawLadder(mc, m, yHorizon);
+      drawLadder(mc, context, yHorizon);
     }
 
-    drawReferenceMark(mc, m, yHorizon, CONFIG.pitchLadder_optimumClimbAngle);
-    drawReferenceMark(mc, m, yHorizon, CONFIG.pitchLadder_optimumGlideAngle);
+    drawReferenceMark(mc, context, yHorizon, CONFIG.pitchLadder_optimumClimbAngle);
+    drawReferenceMark(mc, context, yHorizon, CONFIG.pitchLadder_optimumGlideAngle);
 
     if (CONFIG.pitchLadder_showHorizon) {
       pitchData.l1 -= pitchData.margin;
       pitchData.r2 += pitchData.margin;
-      drawDegreeBar(mc, m, 0, yHorizon);
+      drawDegreeBar(mc, context, 0, yHorizon);
     }
 
     if (CONFIG.pitchLadder_showRoll) {
-      m.pop();
+      matrixes.pop();
     }
   }
 
-  private void drawLadder(MinecraftClient mc, MatrixStack m, float yHorizon) {
+  private void drawLadder(MinecraftClient mc, DrawContext context, float yHorizon) {
     int degreesPerBar = CONFIG.pitchLadder_degreesPerBar;
 
     if (degreesPerBar < 1) {
@@ -62,19 +64,19 @@ private void drawLadder(MinecraftClient mc, MatrixStack m, float yHorizon) {
     }
 
     for (int i = degreesPerBar; i <= 90; i = i + degreesPerBar) {
-      float offset = dim.degreesPerPixel * i;
-      drawDegreeBar(mc, m, -i, yHorizon + offset);
-      drawDegreeBar(mc, m, i, yHorizon - offset);
+      float offset = dim.pixelsPerDegree * i;
+      drawDegreeBar(mc, context, -i, yHorizon + offset);
+      drawDegreeBar(mc, context, i, yHorizon - offset);
     }
 
   }
 
-  private void drawReferenceMark(MinecraftClient mc, MatrixStack m, float yHorizon, float degrees) {
+  private void drawReferenceMark(MinecraftClient mc, DrawContext context, float yHorizon, float degrees) {
     if (degrees == 0) {
       return;
     }
 
-    float y = (-degrees * dim.degreesPerPixel) + yHorizon;
+    float y = (-degrees * dim.pixelsPerDegree) + yHorizon;
 
     if (y < dim.tFrame || y > dim.bFrame) {
       return;
@@ -84,11 +86,11 @@ private void drawReferenceMark(MinecraftClient mc, MatrixStack m, float yHorizon
     float l1 = pitchData.l2 - width;
     float r2 = pitchData.r1 + width;
 
-    drawHorizontalLineDashed(m, l1, pitchData.l2, y, 3);
-    drawHorizontalLineDashed(m, pitchData.r1, r2, y, 3);
+    drawHorizontalLineDashed(context, l1, pitchData.l2, y, 3);
+    drawHorizontalLineDashed(context, pitchData.r1, r2, y, 3);
   }
 
-  private void drawDegreeBar(MinecraftClient mc, MatrixStack m, float degree, float y) {
+  private void drawDegreeBar(MinecraftClient mc, DrawContext context, float degree, float y) {
 
     if (y < dim.tFrame || y > dim.bFrame) {
       return;
@@ -96,19 +98,19 @@ private void drawDegreeBar(MinecraftClient mc, MatrixStack m, float degree, floa
 
     int dashes = degree < 0 ? 4 : 1;
 
-    drawHorizontalLineDashed(m, pitchData.l1, pitchData.l2, y, dashes);
-    drawHorizontalLineDashed(m, pitchData.r1, pitchData.r2, y, dashes);
+    drawHorizontalLineDashed(context, pitchData.l1, pitchData.l2, y, dashes);
+    drawHorizontalLineDashed(context, pitchData.r1, pitchData.r2, y, dashes);
 
     int sideTickHeight = degree >= 0 ? 5 : -5;
-    drawVerticalLine(m, pitchData.l1, y, y + sideTickHeight);
-    drawVerticalLine(m, pitchData.r2, y, y + sideTickHeight);
+    drawVerticalLine(context, pitchData.l1, y, y + sideTickHeight);
+    drawVerticalLine(context, pitchData.r2, y, y + sideTickHeight);
 
     int fontVerticalOffset = degree >= 0 ? 0 : 6;
 
-    drawFont(mc, m, String.format("%d", i(Math.abs(degree))), pitchData.r2 + 6,
+    drawFont(mc, context, String.format("%d", i(Math.abs(degree))), pitchData.r2 + 6,
         (float) y - fontVerticalOffset);
 
-    drawFont(mc, m, String.format("%d", i(Math.abs(degree))), pitchData.l1 - 17,
+    drawFont(mc, context, String.format("%d", i(Math.abs(degree))), pitchData.l1 - 17,
         (float) y - fontVerticalOffset);
   }
 
diff --git a/src/main/java/net/torocraft/flighthud/components/SpeedIndicator.java b/src/main/java/net/torocraft/flighthud/components/SpeedIndicator.java
index f6e6fab..2cca87f 100644
--- a/src/main/java/net/torocraft/flighthud/components/SpeedIndicator.java
+++ b/src/main/java/net/torocraft/flighthud/components/SpeedIndicator.java
@@ -1,10 +1,10 @@
 package net.torocraft.flighthud.components;
 
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.util.math.MatrixStack;
 import net.torocraft.flighthud.Dimensions;
 import net.torocraft.flighthud.FlightComputer;
 import net.torocraft.flighthud.HudComponent;
+import net.minecraft.client.gui.DrawContext;
 
 public class SpeedIndicator extends HudComponent {
   private final Dimensions dim;
@@ -16,7 +16,7 @@ public SpeedIndicator(FlightComputer computer, Dimensions dim) {
   }
 
   @Override
-  public void render(MatrixStack m, float partial, MinecraftClient mc) {
+  public void render(DrawContext context, float partial, MinecraftClient mc) {
     float top = dim.tFrame;
     float bottom = dim.bFrame;
 
@@ -30,8 +30,8 @@ public void render(MatrixStack m, float partial, MinecraftClient mc) {
     float xSpeedText = left - 5;
 
     if (CONFIG.speed_showReadout) {
-      drawRightAlignedFont(mc, m, String.format("%.2f", computer.speed), xSpeedText, dim.yMid - 3);
-      drawBox(m, xSpeedText - 29.5f, dim.yMid - 4.5f, 30, 10);
+      drawRightAlignedFont(mc, context, String.format("%.2f", computer.speed), xSpeedText, dim.yMid - 3);
+      drawBox(context, xSpeedText - 29.5f, dim.yMid - 4.5f, 30, 10);
     }
 
 
@@ -42,12 +42,12 @@ public void render(MatrixStack m, float partial, MinecraftClient mc) {
           continue;
 
         if (i % 1 == 0) {
-          drawHorizontalLine(m, left - 2, right, y);
+          drawHorizontalLine(context, left - 2, right, y);
           if (!CONFIG.speed_showReadout || y > dim.yMid + 7 || y < dim.yMid - 7) {
-            drawRightAlignedFont(mc, m, String.format("%.0f", i), xSpeedText, y - 3);
+            drawRightAlignedFont(mc, context, String.format("%.0f", i), xSpeedText, y - 3);
           }
         }
-        drawHorizontalLine(m, left, right, y);
+        drawHorizontalLine(context, left, right, y);
       }
     }
   }
diff --git a/src/main/java/net/torocraft/flighthud/config/SettingsConfig.java b/src/main/java/net/torocraft/flighthud/config/SettingsConfig.java
index bdb1938..2e21fe2 100644
--- a/src/main/java/net/torocraft/flighthud/config/SettingsConfig.java
+++ b/src/main/java/net/torocraft/flighthud/config/SettingsConfig.java
@@ -14,8 +14,6 @@ public enum DisplayMode {
   public String displayModeWhenFlying = DisplayMode.FULL.toString();
   public String displayModeWhenNotFlying = DisplayMode.NONE.toString();
   public boolean calculateRoll = true;
-  public float rollTurningForce = 1.25f;
-  public float rollSmoothing = 0.85f;
 
   @Override
   public void update() {
diff --git a/src/main/java/net/torocraft/flighthud/mixin/GameRendererMixin.java b/src/main/java/net/torocraft/flighthud/mixin/GameRendererMixin.java
new file mode 100644
index 0000000..23c891d
--- /dev/null
+++ b/src/main/java/net/torocraft/flighthud/mixin/GameRendererMixin.java
@@ -0,0 +1,45 @@
+package net.torocraft.flighthud.mixin;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.Camera;
+import net.minecraft.client.render.GameRenderer;
+import net.minecraft.client.render.RenderTickCounter;
+
+import org.joml.Quaternionf;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import static net.torocraft.flighthud.FlightHud.computer;
+
+@Mixin(GameRenderer.class)
+public class GameRendererMixin {
+    @Shadow
+    @Final
+    private Camera camera;
+    @Shadow
+    @Final
+    MinecraftClient client;
+
+    @Inject(
+            method = "renderWorld",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/client/render/GameRenderer;loadProjectionMatrix(Lorg/joml/Matrix4f;)V",
+                    shift = At.Shift.AFTER
+            )
+    )
+    private void renderWorld(
+            RenderTickCounter tickCounter,
+            CallbackInfo ci
+    ) {
+        if(camera != null){
+            computer.update(client,camera.getRotation());
+        } else{
+            computer.update(client, new Quaternionf(0.8775826, 0.0440319, 0, 0));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/net/torocraft/flighthud/mixin/InGameHudMixin.java b/src/main/java/net/torocraft/flighthud/mixin/InGameHudMixin.java
index 9b0d1b4..6b695ee 100644
--- a/src/main/java/net/torocraft/flighthud/mixin/InGameHudMixin.java
+++ b/src/main/java/net/torocraft/flighthud/mixin/InGameHudMixin.java
@@ -1,8 +1,9 @@
 package net.torocraft.flighthud.mixin;
 
 import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.DrawContext;
 import net.minecraft.client.gui.hud.InGameHud;
-import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.render.RenderTickCounter;
 import net.torocraft.flighthud.HudRenderer;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -23,7 +24,7 @@ public class InGameHudMixin {
   private MinecraftClient client;
 
   @Inject(method = "render", at = @At("RETURN"))
-  private void render(MatrixStack ms, float partial, CallbackInfo info) {
-    hud.render(ms, partial, client);
+  private void render(DrawContext context, RenderTickCounter tickCounter, CallbackInfo ci) {
+    hud.render(context,tickCounter.getTickDelta(false), client);
   }
 }
\ No newline at end of file
diff --git a/src/main/resources/flighthud.mixins.json b/src/main/resources/flighthud.mixins.json
index 95dbf8d..7ced40c 100644
--- a/src/main/resources/flighthud.mixins.json
+++ b/src/main/resources/flighthud.mixins.json
@@ -1,10 +1,11 @@
 {
   "required": true,
   "package": "net.torocraft.flighthud.mixin",
-  "compatibilityLevel": "JAVA_17",
+  "compatibilityLevel": "JAVA_21",
   "mixins": [],
   "client": [
-    "InGameHudMixin"
+    "InGameHudMixin",
+    "GameRendererMixin"
   ],
   "injectors": {
     "defaultRequire": 1