diff --git a/src/hittable.zig b/src/hittable.zig
index 8ea8f23..81c1119 100644
--- a/src/hittable.zig
+++ b/src/hittable.zig
@@ -2,7 +2,7 @@ const std = @import("std");
 
 const zm = @import("zmath");
 
-const IntervalF32 = @import("interval.zig").IntervalF32;
+const IntervalF32 = @import("a").interval.IntervalF32;
 const Material = @import("material.zig").Material;
 const Ray = @import("ray.zig");
 
diff --git a/src/hittable/sphere.zig b/src/hittable/sphere.zig
index 6324aa2..b4a5270 100644
--- a/src/hittable/sphere.zig
+++ b/src/hittable/sphere.zig
@@ -1,6 +1,6 @@
 const zm = @import("zmath");
 
-const IntervalF32 = @import("../interval.zig").IntervalF32;
+const IntervalF32 = @import("a").interval.IntervalF32;
 const Ray = @import("../ray.zig");
 const HitRecord = @import("../hittable.zig").HitRecord;
 const Material = @import("../material.zig").Material;
diff --git a/src/interval.zig b/src/interval.zig
deleted file mode 100644
index a267dc3..0000000
--- a/src/interval.zig
+++ /dev/null
@@ -1,136 +0,0 @@
-const std = @import("std");
-
-pub const IntervalU8 = Interval(u8);
-pub const IntervalU16 = Interval(u16);
-pub const IntervalU32 = Interval(u32);
-pub const IntervalU64 = Interval(u64);
-pub const IntervalUsize = Interval(usize);
-
-pub const IntervalI8 = Interval(i8);
-pub const IntervalI16 = Interval(i16);
-pub const IntervalI32 = Interval(i32);
-pub const IntervalI64 = Interval(i64);
-pub const IntervalIsize = Interval(isize);
-
-pub const IntervalF32 = Interval(f32);
-pub const IntervalF64 = Interval(f64);
-
-pub const IntervalIteratorType = enum {
-    inclusive,
-    exclusive,
-};
-
-pub fn Interval(comptime T: type) type {
-    if (@typeInfo(T) == .Int) {
-        return IntInterval(T);
-    } else if (@typeInfo(T) == .Float) {
-        return FloatInterval(T);
-    } else {
-        @compileError("Interval only supports Int and Float Types!");
-    }
-}
-
-fn IntInterval(comptime T: type) type {
-    return struct {
-        const Self = @This();
-
-        pub const empty: Self = .{ .min = std.math.inf(T), .max = -std.math.inf(T) };
-        pub const universe: Self = .{ .min = -std.math.inf(T), .max = std.math.inf(T) };
-
-        pub const Iterator = struct {
-            interval: Self,
-            current: T,
-
-            lower_boundry: IntervalIteratorType = .inclusive,
-            upper_boundry: IntervalIteratorType = .exclusive,
-
-            pub fn init(
-                interval: Self,
-                lower_boundry: IntervalIteratorType,
-                upper_boundry: IntervalIteratorType,
-            ) Iterator {
-                return .{
-                    .interval = interval,
-                    .current = if (lower_boundry == .inclusive) interval.min else interval.min + 1,
-                    .lower_boundry = lower_boundry,
-                    .upper_boundry = upper_boundry,
-                };
-            }
-
-            pub fn next(self: *Iterator) ?T {
-                self.current += 1;
-                if (self.current < self.interval.max or (self.current == self.interval.max and self.upper_boundry == .inclusive)) {
-                    return self.current;
-                } else return null;
-            }
-
-            pub fn nextInc(self: *Iterator) ?T {
-                self.current += 1;
-                return if (self.current <= self.interval.max) self.current else null;
-            }
-
-            pub fn nextExc(self: *Iterator) ?T {
-                self.current += 1;
-                return if (self.current < self.interval.max) self.current else null;
-            }
-        };
-
-        min: T,
-        max: T,
-
-        pub fn init(min: T, max: T) Interval {
-            return .{ .min = min, .max = max };
-        }
-
-        pub fn contains(self: *const Self, x: T) bool {
-            return self.min <= x and x <= self.max;
-        }
-
-        pub fn surrounds(self: *const Self, x: T) bool {
-            return self.min < x and x < self.max;
-        }
-
-        pub fn clamp(self: *const Self, x: T) T {
-            if (x < self.min) return self.min;
-            if (x > self.max) return self.max;
-            return x;
-        }
-
-        pub fn iter(self: *const Self) Iterator {
-            return Iterator{
-                .interval = self.*,
-                .current = self.min,
-            };
-        }
-    };
-}
-
-fn FloatInterval(comptime T: type) type {
-    return struct {
-        pub const empty: @This() = .{ .min = std.math.inf(T), .max = -std.math.inf(T) };
-        pub const universe: @This() = .{ .min = -std.math.inf(T), .max = std.math.inf(T) };
-
-        const Self = @This();
-
-        min: T,
-        max: T,
-
-        pub fn init(min: T, max: T) Self {
-            return .{ .min = min, .max = max };
-        }
-
-        pub fn contains(self: *const Self, x: T) bool {
-            return self.min <= x and x <= self.max;
-        }
-
-        pub fn surrounds(self: *const Self, x: T) bool {
-            return self.min < x and x < self.max;
-        }
-
-        pub fn clamp(self: *const Self, x: T) T {
-            if (x < self.min) return self.min;
-            if (x > self.max) return self.max;
-            return x;
-        }
-    };
-}
diff --git a/src/rayray.zig b/src/rayray.zig
index 076ab77..3da486f 100644
--- a/src/rayray.zig
+++ b/src/rayray.zig
@@ -6,11 +6,10 @@ const color = zigimg.color;
 
 pub const Camera = @import("camera.zig");
 pub const hittable = @import("hittable.zig");
-pub const interval = @import("interval.zig");
 pub const material = @import("material.zig");
 pub const renderer = @import("renderer.zig");
 
-const IntervalUsize = @import("interval.zig").IntervalUsize;
+const IntervalUsize = @import("a").interval.IntervalUsize;
 
 const log = std.log.scoped(.rayray);
 
diff --git a/src/renderer.zig b/src/renderer.zig
index e5f6d47..d2b11cc 100644
--- a/src/renderer.zig
+++ b/src/renderer.zig
@@ -10,7 +10,7 @@ const material = @import("material.zig");
 const Ray = @import("ray.zig");
 const util = @import("util.zig");
 
-const interval = @import("interval.zig");
+const interval = @import("a").interval;
 const IntervalUsize = interval.IntervalUsize;
 const IntervalF32 = interval.IntervalF32;