diff --git a/apps/fsapp.app/operations.js b/apps/fsapp.app/operations.js
index d6478340..2e1a1eaa 100644
--- a/apps/fsapp.app/operations.js
+++ b/apps/fsapp.app/operations.js
@@ -58,374 +58,65 @@ async function filePickerAction(selected) {
 
 async function fileAction(selected) {
     if (selected.length === 1) {
-        // SINGLE FILE SELECTION //
-
         var fileSelected = selected[0];
         if (fileSelected.getAttribute("data-type") === "file") {
             console.debug("Clicked on file");
             if (
-                fileSelected
-                    .getAttribute("data-path")
-                    .split(".")
-                    .slice("-2")
-                    .join(".") === "app.zip"
+                fileSelected.getAttribute("data-path").endsWith(".app.zip") ||
+                fileSelected.getAttribute("data-path").endsWith(".lib.zip")
             ) {
-                let data = await fs.promises.readFile(
-                    fileSelected.getAttribute("data-path"),
-                );
-
-                const path = fileSelected
-                    .getAttribute("data-path")
-                    .split(".")
-                    .slice(0, -1)
-                    .join(".");
-
-                const zip = await unzip(new Uint8Array(data));
-                const manifest = JSON.parse(
-                    new TextDecoder().decode(zip["manifest.json"]),
-                );
-                const icon = new Blob([zip[manifest.icon]], {
-                    type: mime.default.getType(manifest.icon),
-                });
-                const win = anura.wm.create(instance, {
-                    title: "",
-                    width: "450px",
-                    height: "525px",
-                });
-
-                const iframe = document.createElement("iframe");
-
-                iframe.setAttribute(
-                    "src",
-                    document.location.href.split("/").slice(0, -1).join("/") +
-                        "/appview.html?manifest=" +
-                        ExternalApp.serializeArgs([
-                            JSON.stringify(manifest),
-                            URL.createObjectURL(icon),
-                            "app",
-                        ]),
-                );
-
-                iframe.style =
-                    "top:0; left:0; bottom:0; right:0; width:100%; height:100%; border:none; margin:0; padding:0;";
-
-                win.content.appendChild(iframe);
-
-                Object.assign(iframe.contentWindow, {
-                    anura,
-                    ExternalApp,
-                    instance,
-                    instanceWindow: win,
-                    install: {
-                        session: async () => {
-                            anura.notifications.add({
-                                title: "Application Installing for Session",
-                                description: `Application ${path.replace(
-                                    "//",
-                                    "/",
-                                )} is being installed, please wait`,
-                                timeout: 50000,
-                            });
-                            await fs.mkdir(`${path.replace("//", "/")}`);
-                            try {
-                                for (const [
-                                    relativePath,
-                                    content,
-                                ] of Object.entries(zip)) {
-                                    if (relativePath.endsWith("/")) {
-                                        fs.mkdir(`${path}/${relativePath}`);
-                                    } else {
-                                        fs.writeFile(
-                                            `${path}/${relativePath}`,
-                                            await Buffer.from(content),
-                                        );
-                                    }
-                                }
-                                await anura.registerExternalApp(
-                                    `/fs${path}`.replace("//", "/"),
-                                );
-                                anura.notifications.add({
-                                    title: "Application Installed for Session",
-                                    description: `Application ${path.replace(
-                                        "//",
-                                        "/",
-                                    )} has been installed temporarily, it will go away on refresh`,
-                                    timeout: 50000,
-                                });
-                            } catch (e) {
-                                console.error(e);
-                            }
-                        },
-                        permanent: async () => {
-                            anura.notifications.add({
-                                title: "Application Installing",
-                                description: `Application ${path.replace(
-                                    "//",
-                                    "/",
-                                )} is being installed, please wait`,
-                                timeout: 50000,
-                            });
-                            await fs.promises.mkdir(
-                                anura.settings.get("directories")["apps"] +
-                                    "/" +
-                                    path.split("/").slice("-1")[0],
-                            );
-
-                            try {
-                                for (const [
-                                    relativePath,
-                                    content,
-                                ] of Object.entries(zip)) {
-                                    if (relativePath.endsWith("/")) {
-                                        await fs.promises.mkdir(
-                                            `${anura.settings.get("directories")["apps"]}/${path.split("/").slice("-1")[0]}/${relativePath}`,
-                                        );
-                                    } else {
-                                        await fs.promises.writeFile(
-                                            `${anura.settings.get("directories")["apps"]}/${path.split("/").slice("-1")[0]}/${relativePath}`,
-                                            Buffer.from(content),
-                                        );
-                                    }
-                                }
-                                await anura.registerExternalApp(
-                                    `/fs${anura.settings.get("directories")["apps"]}/${path.split("/").slice("-1")[0]}`.replace(
-                                        "//",
-                                        "/",
-                                    ),
-                                );
-                                anura.notifications.add({
-                                    title: "Application Installed",
-                                    description: `Application ${path.replace(
-                                        "//",
-                                        "/",
-                                    )} has been installed permanently`,
-                                    timeout: 50000,
-                                });
-                            } catch (e) {
-                                console.error(e);
-                            }
-                        },
-                    },
-                });
-
-                iframe.contentWindow.addEventListener("load", () => {
-                    const matter = document.createElement("link");
-                    matter.setAttribute("rel", "stylesheet");
-                    matter.setAttribute("href", "/assets/matter.css");
-                    iframe.contentDocument.head.appendChild(matter);
-                });
-            } else if (
-                fileSelected
-                    .getAttribute("data-path")
-                    .split(".")
-                    .slice("-2")
-                    .join(".") === "lib.zip"
-            ) {
-                const data = await fs.promises.readFile(
-                    fileSelected.getAttribute("data-path"),
-                );
-
-                const path = fileSelected
-                    .getAttribute("data-path")
-                    .split(".")
-                    .slice(0, -1)
-                    .join(".");
-
-                const zip = await unzip(new Uint8Array(data));
-                const manifest = JSON.parse(
-                    new TextDecoder().decode(zip["manifest.json"]),
-                );
-                const icon = new Blob([zip[manifest.icon]], {
-                    type: mime.default.getType(manifest.icon),
-                });
-
-                const win = anura.wm.create(instance, {
-                    title: "",
-                    width: "450px",
-                    height: "525px",
-                });
-
-                const iframe = document.createElement("iframe");
+                anura.files.open(fileSelected.getAttribute("data-path"));
+            }
 
-                iframe.setAttribute(
-                    "src",
-                    document.location.href.split("/").slice(0, -1).join("/") +
-                        "/appview.html?manifest=" +
-                        ExternalApp.serializeArgs([
-                            JSON.stringify(manifest),
-                            URL.createObjectURL(icon),
-                            "lib",
-                        ]),
+            if (fileSelected.getAttribute("data-path").endsWith(".zip")) {
+                const data = await unzip(
+                    await anura.fs.promises.readFile(
+                        fileSelected.getAttribute("data-path"),
+                    ),
                 );
-
-                iframe.style =
-                    "top:0; left:0; bottom:0; right:0; width:100%; height:100%; border:none; margin:0; padding:0;";
-
-                win.content.appendChild(iframe);
-
-                Object.assign(iframe.contentWindow, {
-                    anura,
-                    ExternalApp,
-                    instance,
-                    instanceWindow: win,
-                    install: {
-                        session: async () => {
-                            anura.notifications.add({
-                                title: "Library Installing for Session",
-                                description: `Library ${path.replace(
-                                    "//",
-                                    "/",
-                                )} is being installed, please wait`,
-                                timeout: 50000,
-                            });
-                            await fs.promises.mkdir(`${path}`);
-
-                            let filesRemaining = Object.keys(zip).length;
-
-                            Object.entries(zip).forEach(
-                                async ([relativePath, content]) => {
-                                    if (relativePath.endsWith("/")) {
-                                        await fs.promises.mkdir(
-                                            `${path}/${relativePath}`,
-                                        );
-                                    } else {
-                                        await fs.promises.writeFile(
-                                            `${path}/${relativePath}`,
-                                            Buffer.from(content),
-                                        );
-                                    }
-                                    filesRemaining--;
-                                    if (filesRemaining === 0) {
-                                        await anura.registerExternalLib(
-                                            `/fs/${path}`.replace("//", "/"),
-                                        );
-                                        anura.notifications.add({
-                                            title: "Library Installed for Session",
-                                            description: `Library ${path.replace(
-                                                "//",
-                                                "/",
-                                            )} has been installed temporarily, it will go away on refresh`,
-                                            timeout: 50000,
-                                        });
-                                    }
-                                },
-                                function (e) {
-                                    console.error(e);
-                                },
-                            );
-                        },
-                        permanent: async () => {
-                            anura.notifications.add({
-                                title: "Library Installing",
-                                description: `Library ${path.replace(
-                                    "//",
-                                    "/",
-                                )} is being installed`,
-                                timeout: 50000,
-                            });
-                            await fs.mkdir(
-                                anura.settings.get("directories")["libs"] +
-                                    "/" +
-                                    path.split("/").slice("-1")[0],
-                            );
-
-                            let filesRemaining = Object.keys(zip).length;
-
-                            Object.entries(zip).forEach(
-                                async ([relativePath, content]) => {
-                                    if (relativePath.endsWith("/")) {
-                                        await fs.promises.mkdir(
-                                            `${anura.settings.get("directories")["libs"]}/${path.split("/").slice("-1")[0]}/${relativePath}`,
-                                        );
-                                    } else {
-                                        await fs.promises.writeFile(
-                                            `${anura.settings.get("directories")["libs"]}/${path.split("/").slice("-1")[0]}/${relativePath}`,
-                                            Buffer.from(content),
-                                        );
-                                    }
-                                    filesRemaining--;
-                                    if (filesRemaining === 0) {
-                                        await anura.registerExternalLib(
-                                            `/fs${anura.settings.get("directories")["libs"]}/${path.split("/").slice("-1")[0]}`.replace(
-                                                "//",
-                                                "/",
-                                            ),
-                                        );
-                                        anura.notifications.add({
-                                            title: "Library Installed",
-                                            description: `Library ${path.replace(
-                                                "//",
-                                                "/",
-                                            )} has been installed permanently`,
-                                            timeout: 50000,
-                                        });
-                                    }
-                                },
-                                function (e) {
-                                    console.error(e);
-                                },
-                            );
-                        },
-                    },
-                });
-
-                iframe.contentWindow.addEventListener("load", () => {
-                    const matter = document.createElement("link");
-                    matter.setAttribute("rel", "stylesheet");
-                    matter.setAttribute("href", "/assets/matter.css");
-                    iframe.contentDocument.head.appendChild(matter);
-                });
-            } else {
-                if (fileSelected.getAttribute("data-path").endsWith(".zip")) {
-                    const data = await unzip(
-                        await anura.fs.promises.readFile(
-                            fileSelected.getAttribute("data-path"),
-                        ),
-                    );
-                    const root =
-                        fileSelected
-                            .getAttribute("data-path")
-                            .split("/")
-                            .slice(0, -1)
-                            .join("/") +
-                        "/" +
-                        fileSelected
-                            .getAttribute("data-path")
-                            .split("/")
-                            .pop()
-                            .split(".")
-                            .slice(0, -1)
-                            .join(".") +
-                        "/";
-                    // const folders = [];
-                    const files = [];
-                    for (const item in data) {
-                        console.log(item);
-                        if (item.endsWith("/")) {
-                            // folders.push(item);
-                        } else {
-                            files.push([item, data[item]]);
-                        }
+                const root =
+                    fileSelected
+                        .getAttribute("data-path")
+                        .split("/")
+                        .slice(0, -1)
+                        .join("/") +
+                    "/" +
+                    fileSelected
+                        .getAttribute("data-path")
+                        .split("/")
+                        .pop()
+                        .split(".")
+                        .slice(0, -1)
+                        .join(".") +
+                    "/";
+                // const folders = [];
+                const files = [];
+                for (const item in data) {
+                    console.log(item);
+                    if (item.endsWith("/")) {
+                        // folders.push(item);
+                    } else {
+                        files.push([item, data[item]]);
                     }
-                    const sh = new fs.Shell();
-                    // for (const folder of folders) {
-                    //     await sh.promises.mkdirp(root + folder);
-                    // }
+                }
+                const sh = new fs.Shell();
+                // for (const folder of folders) {
+                //     await sh.promises.mkdirp(root + folder);
+                // }
 
-                    for (const file of files) {
-                        const container =
-                            file[0].split("/").slice(0, -1).join("/") + "/";
-                        await sh.promises.mkdirp(root + container);
+                for (const file of files) {
+                    const container =
+                        file[0].split("/").slice(0, -1).join("/") + "/";
+                    await sh.promises.mkdirp(root + container);
 
-                        await fs.promises.writeFile(
-                            root + file[0],
-                            Buffer.from(file[1]),
-                        );
-                    }
-                    reload();
-                } else {
-                    anura.files.open(fileSelected.getAttribute("data-path"));
+                    await fs.promises.writeFile(
+                        root + file[0],
+                        Buffer.from(file[1]),
+                    );
                 }
+                reload();
+            } else {
+                anura.files.open(fileSelected.getAttribute("data-path"));
             }
         } else if (fileSelected.getAttribute("data-type") === "dir") {
             if (
@@ -435,117 +126,6 @@ async function fileAction(selected) {
                     .slice("-1")[0] === "app"
             ) {
                 try {
-                    let data;
-                    try {
-                        data = await fs.promises.readFile(
-                            `${fileSelected.getAttribute("data-path")}/manifest.json`,
-                        );
-                    } catch {
-                        console.debug(
-                            "Changing folder to ",
-                            fileSelected.getAttribute("data-path"),
-                        );
-                        loadPath(fileSelected.getAttribute("data-path"));
-                        return;
-                    }
-                    const manifest = JSON.parse(data);
-                    if (anura.apps[manifest.package]) {
-                        anura.apps[manifest.package].open();
-                        return;
-                    }
-
-                    const iconData = await fs.promises.readFile(
-                        `${fileSelected.getAttribute("data-path")}/${manifest.icon}`,
-                    );
-
-                    const icon = new Blob([iconData]);
-
-                    const win = anura.wm.create(instance, {
-                        title: "",
-                        width: "450px",
-                        height: "525px",
-                    });
-
-                    const iframe = document.createElement("iframe");
-                    iframe.setAttribute(
-                        "src",
-                        document.location.href
-                            .split("/")
-                            .slice(0, -1)
-                            .join("/") +
-                            "/appview.html?manifest=" +
-                            ExternalApp.serializeArgs([
-                                data.toString(),
-                                URL.createObjectURL(icon),
-                                "app",
-                            ]),
-                    );
-                    iframe.style =
-                        "top:0; left:0; bottom:0; right:0; width:100%; height:100%; border:none; margin:0; padding:0;";
-
-                    win.content.appendChild(iframe);
-                    Object.assign(iframe.contentWindow, {
-                        anura,
-                        ExternalApp,
-                        instance,
-                        instanceWindow: win,
-                        install: {
-                            session: async () => {
-                                await anura.registerExternalApp(
-                                    `/fs${fileSelected.getAttribute("data-path")}`.replace(
-                                        "//",
-                                        "/",
-                                    ),
-                                );
-                                anura.notifications.add({
-                                    title: "Application Installed for Session",
-                                    description: `Application ${fileSelected
-                                        .getAttribute("data-path")
-                                        .replace(
-                                            "//",
-                                            "/",
-                                        )} has been installed temporarily, it will go away on refresh`,
-                                    timeout: 50000,
-                                });
-                                win.close();
-                            },
-                            permanent: async () => {
-                                await fs.promises.rename(
-                                    fileSelected.getAttribute("data-path"),
-                                    anura.settings.get("directories")["apps"] +
-                                        "/" +
-                                        fileSelected
-                                            .getAttribute("data-path")
-                                            .split("/")
-                                            .slice("-1")[0],
-                                );
-                                await anura.registerExternalApp(
-                                    `/fs${anura.settings.get("directories")["apps"]}/${fileSelected.getAttribute("data-path").split("/").slice("-1")[0]}`.replace(
-                                        "//",
-                                        "/",
-                                    ),
-                                );
-                                anura.notifications.add({
-                                    title: "Application Installed",
-                                    description: `Application ${fileSelected
-                                        .getAttribute("data-path")
-                                        .replace(
-                                            "//",
-                                            "/",
-                                        )} has been installed permanently`,
-                                    timeout: 50000,
-                                });
-                                win.close();
-                            },
-                        },
-                    });
-
-                    iframe.contentWindow.addEventListener("load", () => {
-                        const matter = document.createElement("link");
-                        matter.setAttribute("rel", "stylesheet");
-                        matter.setAttribute("href", "/assets/matter.css");
-                        iframe.contentDocument.head.appendChild(matter);
-                    });
                 } catch (e) {
                     anura.dialog.alert(
                         `There was an error: ${e}`,
diff --git a/apps/libfileview.lib/fileHandler.js b/apps/libfileview.lib/fileHandler.js
index 9e7427d2..2803f067 100644
--- a/apps/libfileview.lib/fileHandler.js
+++ b/apps/libfileview.lib/fileHandler.js
@@ -1,3 +1,5 @@
+import { createAppView } from "./pages/appview/appview.js";
+
 const icons = await (await fetch(localPathToURL("icons.json"))).json();
 
 export function openFile(path) {
@@ -117,7 +119,16 @@ export function openFile(path) {
         iframe.srcdoc = data;
         fileView.content.appendChild(iframe);
     }
-
+    switch (path.split(".").slice("-2").join(".")) {
+        case "app.zip":
+            createAppView(path, "app");
+            return;
+        case "lib.zip":
+            createAppView(path, "lib");
+            return;
+        default:
+            break;
+    }
     let ext = path.split(".").slice("-1")[0];
     switch (ext) {
         case "txt":
diff --git a/apps/libfileview.lib/pages/appview/appview.html b/apps/libfileview.lib/pages/appview/appview.html
new file mode 100644
index 00000000..7a150629
--- /dev/null
+++ b/apps/libfileview.lib/pages/appview/appview.html
@@ -0,0 +1,289 @@
+<!doctype html>
+<html>
+    <head>
+        <meta charset="UTF-8" />
+        <title>App Info Viewer</title>
+        <style>
+            @font-face {
+                font-family: Roboto;
+                src: url("/assets/fonts/Roboto-Regular.ttf") format("truetype");
+            }
+
+            html {
+                height: 100%;
+                width: 100%;
+            }
+            .app-info-mnt {
+                display: none;
+            }
+
+            body {
+                background-color: #202124;
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+                justify-content: center;
+                color: white;
+                margin: 0;
+                font-family: Roboto, sans-serif;
+                overflow: scroll;
+            }
+
+            ::-webkit-scrollbar {
+                display: none;
+            }
+
+            #app-title {
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+                justify-content: center;
+                overflow: hidden;
+                width: 100%;
+            }
+
+            #app-name {
+                font-size: 2rem;
+                margin: 0;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+                max-width: 100%;
+            }
+
+            #app-version {
+                font-size: 1rem;
+                margin: 0;
+            }
+
+            #app-top-info {
+                display: flex;
+                flex-direction: row;
+                align-items: center;
+                justify-content: center;
+                width: calc(100% - 56px);
+                gap: 1rem;
+            }
+            #install-button-strip {
+                position: absolute;
+                bottom: 5px;
+            }
+            #install-button-strip > button {
+                margin: 10px;
+            }
+
+            #app-logo {
+                height: 128px;
+                width: 128px;
+                flex-shrink: 0;
+            }
+
+            #app-logo img {
+                height: 100%;
+                width: 100%;
+            }
+
+            #app-divider {
+                margin: 1rem 0;
+                height: 1px;
+                background-color: #9ca3af;
+                flex-shrink: 0;
+                width: calc(100% - 56px);
+            }
+
+            #app-info {
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+                justify-content: center;
+                gap: 1rem;
+                padding-bottom: 1rem;
+                width: calc(100% - 56px);
+            }
+
+            .mono {
+                font-family:
+                    Roboto Mono,
+                    monospace;
+            }
+
+            table {
+                width: 100%;
+                border-collapse: collapse;
+            }
+
+            td,
+            th {
+                padding: 0.5rem;
+                border: 1px solid #555;
+                text-align: left;
+            }
+
+            tr {
+                background-color: #2d2f33;
+            }
+        </style>
+        <script>
+            const url = new URL(window.location.href);
+            const args = ExternalApp.deserializeArgs(
+                url.searchParams.get("manifest"),
+            );
+            if (!args) {
+                console.error("No args found");
+                instanceWindow.close();
+            }
+            console.log(args);
+            window.manifest = JSON.parse(args[0]);
+            window.iconurl = args[1];
+            window.isLib = args[2] === "lib";
+        </script>
+    </head>
+    <body>
+        <div id="app-top-info">
+            <div id="app-logo"></div>
+            <div id="app-title">
+                <h1 id="app-name"></h1>
+                <span id="app-version"></span>
+            </div>
+        </div>
+        <div id="app-divider"></div>
+        <div id="app-info">
+            <span id="button-strip"
+                ><button
+                    class="matter-button-contained"
+                    id="manifestButton"
+                    onclick="manifestShow()"
+                >
+                    Manifest
+                </button></span
+            >
+            <table id="app-info-mnt" style=""></table>
+        </div>
+        <span id="install-button-strip"></span>
+        <script>
+            let currentlyShowingMenu = document.getElementById("app-info-mnt");
+            let currentlyShowingButton =
+                document.getElementById("manifestButton");
+            function manifestShow() {
+                const appInfoTable = document.getElementById("app-info-mnt");
+                const appInfoButton = document.getElementById("manifestButton");
+                if (appInfoTable !== currentlyShowingMenu) {
+                    currentlyShowingMenu.style.display = "none";
+                    appInfoTable.style.display = "";
+                    currentlyShowingMenu = appInfoTable;
+                    currentlyShowingButton.className = "matter-button-text";
+                    appInfoButton.className = "matter-button-contained";
+                    currentlyShowingButton = appInfoButton;
+                }
+            }
+
+            const appName = document.querySelector("#app-name");
+            appName.innerText = manifest.name;
+
+            const appVersion = document.querySelector("#app-version");
+            if (isLib) {
+                appVersion.innerText =
+                    "v" + (manifest.currentVersion || "0.0.0");
+
+                if (!manifest.currentVersion) {
+                    appVersion.title =
+                        "No version information found in manifest.";
+                    // This library is not compliant if this happens.
+                }
+            } else {
+                appVersion.innerText = "v" + (manifest.version || "0.0.0");
+
+                if (!manifest.version) {
+                    appVersion.title =
+                        "No version information found in manifest.";
+                }
+            }
+
+            const appLogo = document.querySelector("#app-logo");
+
+            const img = document.createElement("img");
+            img.src = iconurl;
+            img.alt = manifest.name;
+            appLogo.appendChild(img);
+
+            const appInfoMnt = document.querySelector("#app-info-mnt");
+
+            appInfoMnt.classList.add("mono");
+
+            function parseObject(table, object) {
+                let headerRow = document.createElement("tr");
+                let headerKey = document.createElement("th");
+                let headerValue = document.createElement("th");
+                headerKey.innerText = "Key";
+                headerValue.innerText = "Value";
+                headerRow.appendChild(headerKey);
+                headerRow.appendChild(headerValue);
+                table.appendChild(headerRow);
+                Object.entries(object).forEach(([key, value]) => {
+                    if (typeof value === "object") {
+                        const subTable = document.createElement("table");
+                        parseObject(subTable, value);
+                        subTable.style.display = "none";
+
+                        const subTableTitle = document.createElement("button");
+                        subTableTitle.className = "matter-button-text";
+                        subTableTitle.innerText = key;
+                        subTableTitle.onclick = () => {
+                            if (subTable !== currentlyShowingMenu) {
+                                currentlyShowingMenu.style.display = "none";
+                                subTable.style.display = "";
+                                currentlyShowingMenu = subTable;
+                                currentlyShowingButton.className =
+                                    "matter-button-text";
+                                subTableTitle.className =
+                                    "matter-button-contained";
+                                currentlyShowingButton = subTableTitle;
+                            }
+                        };
+
+                        document
+                            .getElementById("button-strip")
+                            .appendChild(subTableTitle);
+                        document
+                            .getElementById("app-info")
+                            .appendChild(subTable);
+                    } else {
+                        const tr = document.createElement("tr");
+                        const tdKey = document.createElement("td");
+                        const tdValue = document.createElement("td");
+                        tdKey.innerText = key;
+                        tdValue.innerText = value;
+                        tr.appendChild(tdKey);
+                        tr.appendChild(tdValue);
+                        table.appendChild(tr);
+                    }
+                });
+            }
+
+            parseObject(appInfoMnt, window.manifest);
+
+            if (window.install) {
+                if (window.install.session) {
+                    const button = document.createElement("button");
+                    button.innerText = "Install For Session";
+                    button.classList.add("matter-button-contained");
+                    button.style.backgroundColor = "#4f46e5";
+                    button.onclick = window.install.session;
+                    document
+                        .getElementById("install-button-strip")
+                        .appendChild(button);
+                }
+                if (window.install.permanent) {
+                    const button = document.createElement("button");
+                    button.innerText = "Install Permanently";
+                    button.classList.add("matter-button-contained");
+                    button.style.backgroundColor = "#22b30f";
+                    button.onclick = window.install.permanent;
+                    document
+                        .getElementById("install-button-strip")
+                        .appendChild(button);
+                }
+            }
+        </script>
+    </body>
+</html>
diff --git a/apps/libfileview.lib/pages/appview/appview.js b/apps/libfileview.lib/pages/appview/appview.js
new file mode 100644
index 00000000..0c35cec2
--- /dev/null
+++ b/apps/libfileview.lib/pages/appview/appview.js
@@ -0,0 +1,271 @@
+const fflate = await anura.import("npm:fflate");
+const mime = await anura.import("npm:mime");
+const Buffer = Filer.Buffer;
+
+export async function createAppView(dataPath, type) {
+    let data = await anura.fs.promises.readFile(dataPath);
+
+    const path = dataPath.split(".").slice(0, -1).join(".");
+
+    const zip = await unzip(new Uint8Array(data));
+    const manifest = JSON.parse(new TextDecoder().decode(zip["manifest.json"]));
+    const icon = new Blob([zip[manifest.icon]], {
+        type: mime.default.getType(manifest.icon),
+    });
+
+    const win = anura.wm.createGeneric({
+        title: "",
+        width: "450px",
+        height: "525px",
+    });
+
+    win.onclose = () => {
+        URL.revokeObjectURL(icon);
+    };
+
+    const iframe = document.createElement("iframe");
+
+    iframe.setAttribute(
+        "src",
+        localPathToURL(
+            "appview.html?manifest=" +
+                ExternalApp.serializeArgs([
+                    JSON.stringify(manifest),
+                    URL.createObjectURL(icon),
+                    type,
+                ]),
+        ),
+    );
+
+    iframe.style =
+        "top:0; left:0; bottom:0; right:0; width:100%; height:100%; border:none; margin:0; padding:0;";
+
+    win.content.appendChild(iframe);
+
+    Object.assign(iframe.contentWindow, {
+        anura,
+        ExternalApp,
+        instanceWindow: win,
+        install: {
+            session: async () => {
+                anura.notifications.add({
+                    title: "Installing for Session",
+                    description: `${path.replace(
+                        "//",
+                        "/",
+                    )} is being installed, please wait`,
+                    timeout: 50000,
+                });
+                await anura.fs.mkdir(`${path.replace("//", "/")}`);
+                try {
+                    for (const [relativePath, content] of Object.entries(zip)) {
+                        if (relativePath.endsWith("/")) {
+                            anura.fs.mkdir(`${path}/${relativePath}`);
+                        } else {
+                            anura.fs.writeFile(
+                                `${path}/${relativePath}`,
+                                await Buffer.from(content),
+                            );
+                        }
+                    }
+                    await anura.registerExternalApp(
+                        `/fs${path}`.replace("//", "/"),
+                    );
+                    anura.notifications.add({
+                        title: "Installed for Session",
+                        description: `${path.replace(
+                            "//",
+                            "/",
+                        )} has been installed temporarily, it will go away on refresh`,
+                        timeout: 50000,
+                    });
+                } catch (e) {
+                    console.error(e);
+                }
+            },
+            permanent: async () => {
+                anura.notifications.add({
+                    title: "Installing",
+                    description: `${path.replace(
+                        "//",
+                        "/",
+                    )} is being installed, please wait`,
+                    timeout: 50000,
+                });
+                await anura.fs.promises.mkdir(
+                    // this is a dumb hack but i dont want to make 2 functions
+                    anura.settings.get("directories")[type + "s"] +
+                        "/" +
+                        path.split("/").slice("-1")[0],
+                );
+
+                try {
+                    for (const [relativePath, content] of Object.entries(zip)) {
+                        if (relativePath.endsWith("/")) {
+                            await anura.fs.promises.mkdir(
+                                `${anura.settings.get("directories")[type + "s"]}/${path.split("/").slice("-1")[0]}/${relativePath}`,
+                            );
+                        } else {
+                            await anura.fs.promises.writeFile(
+                                `${anura.settings.get("directories")[type + "s"]}/${path.split("/").slice("-1")[0]}/${relativePath}`,
+                                Buffer.from(content),
+                            );
+                        }
+                    }
+                    await anura.registerExternalApp(
+                        `/fs${anura.settings.get("directories")[type + "s"]}/${path.split("/").slice("-1")[0]}`.replace(
+                            "//",
+                            "/",
+                        ),
+                    );
+                    anura.notifications.add({
+                        title: "Installed",
+                        description: `${path.replace(
+                            "//",
+                            "/",
+                        )} has been installed permanently`,
+                        timeout: 50000,
+                    });
+                } catch (e) {
+                    console.error(e);
+                }
+            },
+        },
+    });
+
+    iframe.contentWindow.addEventListener("load", () => {
+        const matter = document.createElement("link");
+        matter.setAttribute("rel", "stylesheet");
+        matter.setAttribute("href", "/assets/matter.css");
+        iframe.contentDocument.head.appendChild(matter);
+    });
+}
+
+// will do later
+export async function createAppViewFolder() {
+    let data;
+    try {
+        data = await fs.promises.readFile(
+            `${fileSelected.getAttribute("data-path")}/manifest.json`,
+        );
+    } catch {
+        console.debug(
+            "Changing folder to ",
+            fileSelected.getAttribute("data-path"),
+        );
+        loadPath(fileSelected.getAttribute("data-path"));
+        return;
+    }
+    const manifest = JSON.parse(data);
+    if (anura.apps[manifest.package]) {
+        anura.apps[manifest.package].open();
+        return;
+    }
+    if (anura.libs[manifest.package]) {
+        return;
+    }
+
+    const iconData = await fs.promises.readFile(
+        `${fileSelected.getAttribute("data-path")}/${manifest.icon}`,
+    );
+
+    const icon = new Blob([iconData]);
+
+    const win = anura.wm.create(instance, {
+        title: "",
+        width: "450px",
+        height: "525px",
+    });
+
+    const iframe = document.createElement("iframe");
+    iframe.setAttribute(
+        "src",
+        document.location.href.split("/").slice(0, -1).join("/") +
+            "/appview.html?manifest=" +
+            ExternalApp.serializeArgs([
+                data.toString(),
+                URL.createObjectURL(icon),
+                "app",
+            ]),
+    );
+    iframe.style =
+        "top:0; left:0; bottom:0; right:0; width:100%; height:100%; border:none; margin:0; padding:0;";
+
+    win.content.appendChild(iframe);
+    Object.assign(iframe.contentWindow, {
+        anura,
+        ExternalApp,
+        instance,
+        instanceWindow: win,
+        install: {
+            session: async () => {
+                await anura.registerExternalApp(
+                    `/fs${fileSelected.getAttribute("data-path")}`.replace(
+                        "//",
+                        "/",
+                    ),
+                );
+                anura.notifications.add({
+                    title: "Application Installed for Session",
+                    description: `Application ${fileSelected
+                        .getAttribute("data-path")
+                        .replace(
+                            "//",
+                            "/",
+                        )} has been installed temporarily, it will go away on refresh`,
+                    timeout: 50000,
+                });
+                win.close();
+            },
+            permanent: async () => {
+                await fs.promises.rename(
+                    fileSelected.getAttribute("data-path"),
+                    anura.settings.get("directories")["apps"] +
+                        "/" +
+                        fileSelected
+                            .getAttribute("data-path")
+                            .split("/")
+                            .slice("-1")[0],
+                );
+                await anura.registerExternalApp(
+                    `/fs${anura.settings.get("directories")["apps"]}/${fileSelected.getAttribute("data-path").split("/").slice("-1")[0]}`.replace(
+                        "//",
+                        "/",
+                    ),
+                );
+                anura.notifications.add({
+                    title: "Application Installed",
+                    description: `Application ${fileSelected
+                        .getAttribute("data-path")
+                        .replace("//", "/")} has been installed permanently`,
+                    timeout: 50000,
+                });
+                win.close();
+            },
+        },
+    });
+
+    iframe.contentWindow.addEventListener("load", () => {
+        const matter = document.createElement("link");
+        matter.setAttribute("rel", "stylesheet");
+        matter.setAttribute("href", "/assets/matter.css");
+        iframe.contentDocument.head.appendChild(matter);
+    });
+}
+
+function localPathToURL(path) {
+    return (
+        import.meta.url.substring(0, import.meta.url.lastIndexOf("/")) +
+        "/" +
+        path
+    );
+}
+
+function unzip(zip) {
+    return new Promise((res, rej) => {
+        fflate.unzip(zip, (err, unzipped) => {
+            if (err) rej(err);
+            else res(unzipped);
+        });
+    });
+}