diff --git a/src/main.zig b/src/main.zig
index 7eea06a..66b6bc3 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const xml = @import("./xml.zig");
 
 // Music Player:
 // - Launch VLC and control it via HTTP interface
@@ -20,16 +19,8 @@ pub fn main() !void {
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
 
-    // var vlc = std.process.Child.init(&[_][]const u8{
-    //     "vlc",
-    //     "--intf",
-    //     "http",
-    //     "--http-host",
-    //     "localhost",
-    //     "--http-password",
-    //     "1234",
-    // }, allocator);
-    // try vlc.spawn();
+    var vlc = try VLC.init(allocator, try std.Uri.parse("http://localhost:8080"));
+    defer vlc.deinit();
 
     var tz_file = try std.fs.openFileAbsolute("/etc/localtime", .{});
     defer tz_file.close();
@@ -38,25 +29,24 @@ pub fn main() !void {
 
     while (true) : (std.time.sleep(1_000_000_000)) { // sleep 500ms
         try updateTime(tz);
-        try updateStatus(allocator);
+        try updateStatus(allocator, &vlc);
         scroll += 1;
     }
-
-    // try vlc.kill();
 }
 
 const base64_encoder = std.base64.standard.Encoder;
 
+// TODO make the URL something short like jeevio.xyz/streamboy
 const topic = "Something Fun For Everyone With Streamboy!!!!!!!! git.jeevio.xyz/jeeves/streamboy";
 
 var scroll: usize = 0;
 
-fn updateStatus(allocator: std.mem.Allocator) !void {
+fn updateStatus(allocator: std.mem.Allocator, vlc: *VLC) !void {
     var stream_info_file = try std.fs.createFileAbsolute("/tmp/streaminfo", .{ .truncate = true });
     defer stream_info_file.close();
 
-    var song_info = try getSongInfo(allocator);
-    defer song_info.deinit(allocator);
+    var song_info = try vlc.getSongInfo();
+    defer song_info.deinit();
 
     const string = try std.fmt.allocPrint(allocator, "{s}    |    ♪ {s} - {s}    |    ", .{
         topic,
@@ -72,91 +62,154 @@ fn updateStatus(allocator: std.mem.Allocator) !void {
     }
 }
 
-const SongInfo = struct {
-    title: ?[]const u8,
-    album: ?[]const u8,
-    artist: ?[]const u8,
+pub const VLC = struct {
+    allocator: std.mem.Allocator,
+    http: std.http.Client,
+    base_uri: std.Uri,
+    authorization: []u8,
 
-    pub fn deinit(self: *SongInfo, allocator: std.mem.Allocator) void {
-        if (self.title) |b| allocator.free(b);
-        if (self.album) |b| allocator.free(b);
-        if (self.artist) |b| allocator.free(b);
+    pub fn init(allocator: std.mem.Allocator, base_uri: std.Uri) !VLC {
+        const userpass = try std.fmt.allocPrint(allocator, ":{s}", .{"1234"});
+        defer allocator.free(userpass);
+
+        const base64_userpass = try allocator.alloc(u8, base64_encoder.calcSize(userpass.len));
+        defer allocator.free(base64_userpass);
+
+        const authorization = try std.fmt.allocPrint(allocator, "Basic {s}", .{base64_encoder.encode(base64_userpass, userpass)});
+        errdefer allocator.free(authorization);
+
+        // var vlc = std.process.Child.init(&[_][]const u8{
+        //     "vlc",
+        //     "--intf",
+        //     "http",
+        //     "--http-host",
+        //     "localhost",
+        //     "--http-password",
+        //     "1234",
+        // }, allocator);
+        // try vlc.spawn();
+
+        return .{
+            .allocator = allocator,
+            .http = std.http.Client{ .allocator = allocator },
+            .base_uri = base_uri,
+            .authorization = authorization,
+        };
     }
-};
 
-fn getSongInfo(allocator: std.mem.Allocator) !SongInfo {
-    var http = std.http.Client{ .allocator = allocator };
-    defer http.deinit();
+    pub fn deinit(self: *VLC) void {
+        self.http.deinit();
+        self.allocator.free(self.authorization);
+        // try vlc.kill();
+    }
 
-    const userpass = try std.fmt.allocPrint(allocator, ":{s}", .{"1234"});
-    defer allocator.free(userpass);
+    fn request(self: *VLC, uri: std.Uri) !Response {
+        var combined_uri = self.base_uri;
+        combined_uri.path = uri.path;
+        combined_uri.query = uri.query;
+        combined_uri.fragment = uri.fragment;
 
-    const base64_userpass = try allocator.alloc(u8, base64_encoder.calcSize(userpass.len));
-    defer allocator.free(base64_userpass);
+        var response = std.ArrayList(u8).init(self.allocator);
+        defer response.deinit();
 
-    const final_userpass = try std.fmt.allocPrint(allocator, "Basic {s}", .{base64_encoder.encode(base64_userpass, userpass)});
-    defer allocator.free(final_userpass);
+        const result = try self.http.fetch(.{
+            .location = .{ .uri = combined_uri },
+            .headers = .{ .authorization = .{ .override = self.authorization } },
+            .response_storage = .{ .dynamic = &response },
+        });
 
-    var response = std.ArrayList(u8).init(allocator);
-    defer response.deinit();
+        // std.debug.print("{any}\n{s}\n", .{ result, response.items });
 
-    const result = try http.fetch(.{
-        .location = .{ .url = "http://localhost:8080/requests/status.xml" },
-        .headers = .{ .authorization = .{ .override = final_userpass } },
-        .response_storage = .{ .dynamic = &response },
-    });
+        if (result.status != .ok) return error.HttpRequestFailed;
 
-    std.debug.print("{any}\n{s}\n", .{ result, response.items });
+        const buffer = try response.toOwnedSlice();
+        return .{
+            .buffer = buffer,
+            .document = try xml.parse(self.allocator, buffer),
+        };
+    }
 
-    const document = try xml.parse(allocator, response.items);
-    defer document.deinit();
+    const Response = struct {
+        buffer: []u8,
+        document: xml.Document,
 
-    var title: ?[]const u8 = null;
-    var album: ?[]const u8 = null;
-    var artist: ?[]const u8 = null;
+        pub fn deinit(self: *Response, allocator: std.mem.Allocator) void {
+            self.document.deinit();
+            allocator.free(self.buffer);
+        }
+    };
 
-    if (document.root.findChildByTag("information")) |information| {
-        var categories_it = information.findChildrenByTag("category");
-        while (categories_it.next()) |category| {
-            if (std.mem.eql(u8, category.getAttribute("name").?, "meta")) {
-                var info_it = category.findChildrenByTag("info");
-                while (info_it.next()) |info| {
-                    const info_name = info.getAttribute("name").?;
-                    if (std.mem.eql(u8, info_name, "title"))
-                        title = try processHtmlString(allocator, info.children[0].char_data)
-                    else if (std.mem.eql(u8, info_name, "album"))
-                        album = try processHtmlString(allocator, info.children[0].char_data)
-                    else if (std.mem.eql(u8, info_name, "artist"))
-                        artist = try processHtmlString(allocator, info.children[0].char_data);
+    pub const SongInfo = struct {
+        allocator: std.mem.Allocator,
+        title: ?[]const u8,
+        album: ?[]const u8,
+        artist: ?[]const u8,
+
+        // TODO move allocator into struct
+        pub fn deinit(self: *SongInfo) void {
+            if (self.title) |b| self.allocator.free(b);
+            if (self.album) |b| self.allocator.free(b);
+            if (self.artist) |b| self.allocator.free(b);
+        }
+    };
+
+    pub fn getSongInfo(self: *VLC) !SongInfo {
+        var response = try self.request(.{ .scheme = "http", .path = .{ .percent_encoded = "/requests/status.xml" } });
+        defer response.deinit(self.allocator);
+
+        // std.debug.print("{s}\n", .{response.buffer});
+
+        var title: ?[]const u8 = null;
+        var album: ?[]const u8 = null;
+        var artist: ?[]const u8 = null;
+
+        if (response.document.root.findChildByTag("information")) |information| {
+            var categories_it = information.findChildrenByTag("category");
+            while (categories_it.next()) |category| {
+                if (std.mem.eql(u8, category.getAttribute("name").?, "meta")) {
+                    var info_it = category.findChildrenByTag("info");
+                    while (info_it.next()) |info| {
+                        const info_name = info.getAttribute("name").?;
+                        if (std.mem.eql(u8, info_name, "title"))
+                            title = try processHtmlString(self, info.children[0].char_data)
+                        else if (std.mem.eql(u8, info_name, "album"))
+                            album = try processHtmlString(self, info.children[0].char_data)
+                        else if (std.mem.eql(u8, info_name, "artist"))
+                            artist = try processHtmlString(self, info.children[0].char_data);
+                    }
                 }
             }
         }
+
+        return .{
+            .allocator = self.allocator,
+            .title = title,
+            .album = album,
+            .artist = artist,
+        };
     }
 
-    return .{
-        .title = title,
-        .album = album,
-        .artist = artist,
-    };
-}
-
-fn processHtmlString(allocator: std.mem.Allocator, string: []const u8) ![]const u8 {
-    var new: []u8 = try allocator.dupe(u8, string);
-    errdefer allocator.free(new);
-    while (true) {
-        if (std.mem.indexOf(u8, new, "&#")) |amp| {
-            if (std.mem.indexOfScalarPos(u8, new, amp, ';')) |semi| {
-                const int = try std.fmt.parseInt(u8, new[amp + 2 .. semi], 10);
-                const nnew = try allocator.alloc(u8, std.mem.replacementSize(u8, new, new[amp .. semi + 1], &[1]u8{int}));
-                _ = std.mem.replace(u8, new, new[amp .. semi + 1], &[1]u8{int}, nnew);
-                allocator.free(new);
-                new = nnew;
-            }
-        } else break;
+    // TODO clean up
+    fn processHtmlString(self: *VLC, string: []const u8) ![]const u8 {
+        var new: []u8 = try self.allocator.dupe(u8, string);
+        errdefer self.allocator.free(new);
+        while (true) {
+            if (std.mem.indexOf(u8, new, "&#")) |amp| {
+                if (std.mem.indexOfScalarPos(u8, new, amp, ';')) |semi| {
+                    const int = try std.fmt.parseInt(u8, new[amp + 2 .. semi], 10);
+                    const nnew = try self.allocator.alloc(u8, std.mem.replacementSize(u8, new, new[amp .. semi + 1], &[1]u8{int}));
+                    _ = std.mem.replace(u8, new, new[amp .. semi + 1], &[1]u8{int}, nnew);
+                    self.allocator.free(new);
+                    new = nnew;
+                }
+            } else break;
+        }
+        // std.debug.print("{s}\n", .{new});
+        return new;
     }
-    std.debug.print("{s}\n", .{new});
-    return new;
-}
+
+    const xml = @import("./xml.zig");
+};
 
 fn updateTime(tz: std.Tz) !void {
     const original_timestamp = std.time.timestamp();