diff --git a/file.zig b/file.zig
new file mode 100644
index 0000000..1fac5a8
--- /dev/null
+++ b/file.zig
@@ -0,0 +1,14 @@
+const inode = @import("inode.zig");
+const Reader = @import("squashfs.zig").Reader;
+const MetadataReader = @import("metadata_reader.zig").MetadataReader;
+
+pub const File = struct {
+    rdr: *Reader,
+    inode: inode.Inode,
+    name: []const u8,
+    dir_entries: []const void = undefined, //TODO
+
+    pub fn fromRef(ref: inode.InodeRef, rdr: *Reader) !File {
+        var meta_rdr: MetadataReader = .init(rdr.super.comp, rdr: io.AnyReader, alloc: std.mem.Allocator)
+    }
+};
diff --git a/file_offset_reader.zig b/file_offset_reader.zig
new file mode 100644
index 0000000..0d0017b
--- /dev/null
+++ b/file_offset_reader.zig
@@ -0,0 +1,7 @@
+const std = @import("std");
+
+const FileOffsetReader = struct {
+    file: std.fs.File,
+
+    pub fn any(self: *FileOffsetReader) !std.io.AnyReader {}
+};
diff --git a/inode.zig b/inode.zig
index 6c0927d..35f9036 100644
--- a/inode.zig
+++ b/inode.zig
@@ -73,16 +73,16 @@ pub fn readInode(rdr: io.AnyReader, block_size: u32, alloc: std.mem.Allocator) !
                 .ext_dir = try .init(rdr, alloc),
             },
             .file => .{
-                .file = try file.readFileInode(rdr, block_size, alloc),
+                .file = try .init(rdr, block_size, alloc),
             },
             .ext_file => .{
-                .ext_file = try file.readExtFileInode(rdr, block_size, alloc),
+                .ext_file = try .init(rdr, block_size, alloc),
             },
             .symlink => .{
-                .symlink = try sym.readSymlinkInode(rdr, alloc),
+                .symlink = try .init(rdr, alloc),
             },
             .ext_symlink => .{
-                .ext_symlink = try sym.readExtSymlinkInode(rdr, alloc),
+                .ext_symlink = try .init(rdr, alloc),
             },
             .block_device => .{
                 .block_device = try rdr.readStruct(misc.DeviceInode),
diff --git a/inode_types/dir.zig b/inode_types/dir.zig
index c993fe6..2e00cda 100644
--- a/inode_types/dir.zig
+++ b/inode_types/dir.zig
@@ -53,13 +53,11 @@ pub const ExtDirInode = struct {
             .xattr_index = try rdr.readInt(u32, std.builtin.Endian.little),
             .indexes = undefined,
         };
-        var tmp = std.ArrayList(DirIndex).init(alloc);
-        try tmp.resize(out.dir_index_count);
+        out.indexes = try alloc.alloc(DirIndex, out.dir_index_count);
         var i: u16 = 0;
         while (i < out.dir_index_count) : (i += 1) {
-            tmp.items[i] = try .init(rdr, alloc);
+            out.indexes[i] = try .init(rdr, alloc);
         }
-        out.indexes = tmp.items;
         return out;
     }
 };
diff --git a/inode_types/file.zig b/inode_types/file.zig
index 53e3923..c5811e9 100644
--- a/inode_types/file.zig
+++ b/inode_types/file.zig
@@ -6,24 +6,24 @@ pub const FileInode = struct {
     frag_block_offset: u32,
     size: u32,
     block_sizes: []const u32,
-};
 
-pub fn readFileInode(rdr: std.io.AnyReader, block_size: u32, alloc: std.mem.Allocator) !FileInode {
-    var out = FileInode{
-        .start = try rdr.readInt(u32, std.builtin.Endian.little),
-        .frag_index = try rdr.readInt(u32, std.builtin.Endian.little),
-        .frag_block_offset = try rdr.readInt(u32, std.builtin.Endian.little),
-        .size = try rdr.readInt(u32, std.builtin.Endian.little),
-        .block_sizes = undefined,
-    };
-    var block_num = out.size / block_size;
-    if (out.frag_index != 0xFFFFFFFF) {
-        block_num += 1;
+    pub fn init(rdr: std.io.AnyReader, block_size: u32, alloc: std.mem.Allocator) !FileInode {
+        var out = FileInode{
+            .start = try rdr.readInt(u32, std.builtin.Endian.little),
+            .frag_index = try rdr.readInt(u32, std.builtin.Endian.little),
+            .frag_block_offset = try rdr.readInt(u32, std.builtin.Endian.little),
+            .size = try rdr.readInt(u32, std.builtin.Endian.little),
+            .block_sizes = undefined,
+        };
+        var block_num = out.size / block_size;
+        if (out.frag_index != 0xFFFFFFFF) {
+            block_num += 1;
+        }
+        out.block_sizes = try alloc.alloc(u32, block_num);
+        _ = try rdr.readAll(std.mem.asBytes(&out.block_sizes));
+        return out;
     }
-    out.block_sizes = try alloc.alloc(u32, block_num);
-    _ = try rdr.readAll(std.mem.asBytes(&out.block_sizes));
-    return out;
-}
+};
 
 pub const ExtFileInode = struct {
     start: u64,
@@ -34,24 +34,24 @@ pub const ExtFileInode = struct {
     frag_block_offset: u32,
     xattr_index: u32,
     block_sizes: []const u32,
-};
 
-pub fn readExtFileInode(rdr: std.io.AnyReader, block_size: u32, alloc: std.mem.Allocator) !ExtFileInode {
-    var out = ExtFileInode{
-        .start = try rdr.readInt(u64, std.builtin.Endian.little),
-        .size = try rdr.readInt(u64, std.builtin.Endian.little),
-        .sparse = try rdr.readInt(u64, std.builtin.Endian.little),
-        .hard_links = try rdr.readInt(u32, std.builtin.Endian.little),
-        .frag_index = try rdr.readInt(u32, std.builtin.Endian.little),
-        .frag_block_offset = try rdr.readInt(u32, std.builtin.Endian.little),
-        .xattr_index = try rdr.readInt(u32, std.builtin.Endian.little),
-        .block_sizes = undefined,
-    };
-    var block_num = out.size / block_size;
-    if (out.frag_index != 0xFFFFFFFF and out.size % block_size != 0) {
-        block_num += 1;
+    pub fn init(rdr: std.io.AnyReader, block_size: u32, alloc: std.mem.Allocator) !ExtFileInode {
+        var out = ExtFileInode{
+            .start = try rdr.readInt(u64, std.builtin.Endian.little),
+            .size = try rdr.readInt(u64, std.builtin.Endian.little),
+            .sparse = try rdr.readInt(u64, std.builtin.Endian.little),
+            .hard_links = try rdr.readInt(u32, std.builtin.Endian.little),
+            .frag_index = try rdr.readInt(u32, std.builtin.Endian.little),
+            .frag_block_offset = try rdr.readInt(u32, std.builtin.Endian.little),
+            .xattr_index = try rdr.readInt(u32, std.builtin.Endian.little),
+            .block_sizes = undefined,
+        };
+        var block_num = out.size / block_size;
+        if (out.frag_index != 0xFFFFFFFF and out.size % block_size != 0) {
+            block_num += 1;
+        }
+        out.block_sizes = try alloc.alloc(u32, block_num);
+        _ = try rdr.readAll(std.mem.asBytes(&out.block_sizes));
+        return out;
     }
-    out.block_sizes = try alloc.alloc(u32, block_num);
-    _ = try rdr.readAll(std.mem.asBytes(&out.block_sizes));
-    return out;
-}
+};
diff --git a/inode_types/sym.zig b/inode_types/sym.zig
index 1c5d2b7..3ff7acd 100644
--- a/inode_types/sym.zig
+++ b/inode_types/sym.zig
@@ -5,35 +5,35 @@ pub const SymlinkInode = struct {
     hard_links: u32,
     target_size: u32,
     path: []u8,
-};
 
-pub fn readSymlinkInode(rdr: io.AnyReader, alloc: std.mem.Allocator) !SymlinkInode {
-    var out = SymlinkInode{
-        .hard_links = try rdr.readInt(u32, std.builtin.Endian.little),
-        .target_size = try rdr.readInt(u32, std.builtin.Endian.little),
-        .path = undefined,
-    };
-    out.path = try alloc.alloc(u8, out.target_size + 1);
-    _ = try rdr.readAll(out.path);
-    return out;
-}
+    pub fn init(rdr: io.AnyReader, alloc: std.mem.Allocator) !SymlinkInode {
+        var out = SymlinkInode{
+            .hard_links = try rdr.readInt(u32, std.builtin.Endian.little),
+            .target_size = try rdr.readInt(u32, std.builtin.Endian.little),
+            .path = undefined,
+        };
+        out.path = try alloc.alloc(u8, out.target_size + 1);
+        _ = try rdr.readAll(out.path);
+        return out;
+    }
+};
 
 pub const ExtSymlinkInode = struct {
     hard_links: u32,
     target_size: u32,
     path: []u8,
     xattr_index: u32,
-};
 
-pub fn readExtSymlinkInode(rdr: io.AnyReader, alloc: std.mem.Allocator) !ExtSymlinkInode {
-    var out = ExtSymlinkInode{
-        .hard_links = try rdr.readInt(u32, std.builtin.Endian.little),
-        .target_size = try rdr.readInt(u32, std.builtin.Endian.little),
-        .path = undefined,
-        .xattr_index = undefined,
-    };
-    out.path = try alloc.alloc(u8, out.target_size + 1);
-    _ = try rdr.readAll(out.path);
-    out.xattr_index = try rdr.readInt(u32, std.builtin.Endian.little);
-    return out;
-}
+    pub fn init(rdr: io.AnyReader, alloc: std.mem.Allocator) !ExtSymlinkInode {
+        var out = ExtSymlinkInode{
+            .hard_links = try rdr.readInt(u32, std.builtin.Endian.little),
+            .target_size = try rdr.readInt(u32, std.builtin.Endian.little),
+            .path = undefined,
+            .xattr_index = undefined,
+        };
+        out.path = try alloc.alloc(u8, out.target_size + 1);
+        _ = try rdr.readAll(out.path);
+        out.xattr_index = try rdr.readInt(u32, std.builtin.Endian.little);
+        return out;
+    }
+};
diff --git a/squashfs.zig b/squashfs.zig
index b72f645..055487a 100644
--- a/squashfs.zig
+++ b/squashfs.zig
@@ -4,23 +4,24 @@ const fs = std.fs;
 const Superblock = @import("superblock.zig").Superblock;
 const inode = @import("inode.zig");
 const MetadataReader = @import("metadata_reader.zig").MetadataReader;
+const File = @import("file.zig").File;
 
 pub const Reader = struct {
     super: Superblock,
     rdr: fs.File,
-    root: inode.Inode,
-    alloc: std.heap.ArenaAllocator,
+    root: File,
+    alloc: std.heap.GeneralPurposeAllocator(.{}),
 
     pub fn deinit(self: *Reader) void {
         self.rdr.close();
-        self.alloc.deinit();
+        // _ = self.alloc.deinit();
     }
 };
 
 pub fn newReader(filename: []const u8) !Reader {
     const file = try std.fs.cwd().openFile(filename, .{});
     errdefer file.close();
-    var alloc: std.heap.ArenaAllocator = .init(std.heap.page_allocator);
+    var alloc: std.heap.GeneralPurposeAllocator(.{}) = .init;
     errdefer _ = alloc.deinit();
     const super = try file.reader().readStruct(Superblock);
     try super.valid();
diff --git a/test_squashfs.zig b/test_squashfs.zig
index bc36829..3222bc5 100644
--- a/test_squashfs.zig
+++ b/test_squashfs.zig
@@ -8,5 +8,4 @@ const testFileName = "testing/LinuxPATest.sfs";
 test "open test file" {
     var reader = try squashfs.newReader(testFileName);
     defer reader.deinit();
-    print("{}\n", .{reader.root});
 }