proper fix for disabling sandbox on steamos (#206 )

Co-authored-by: Vendicated <vendicated@riseup.net>
remove electron-builder-sandbox-fix
2023-11-01 01:50:18 +00:00 · 2023-11-01 00:13:28 +01:00 · 2023-10-31 23:18:24 +01:00 · 2023-10-31 22:14:30 +01:00 · 2023-10-30 17:35:24 +00:00 · 2023-10-30 18:25:05 +01:00
98 changed files with 7311 additions and 1091 deletions
--- a/.env.example
+++ b/.env.example
@@ -0,0 +1,8 @@
+# githubs api has a rate limit of 60/h if not authorised.
+# you may quickly hit that and get rate limited. To counteract this, you can provide a github token
+# here and it will be used. To do so, create a token at the following links and just leave
+# all permissions at the defaults (public repos read only, 0 permissions):
+# https://github.com/settings/personal-access-tokens/new
+GITHUB_TOKEN=
+
+ELECTRON_LAUNCH_FLAGS="--ozone-platform-hint=auto --enable-webrtc-pipewire-capturer --enable-features=WaylandWindowDecorations"
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -0,0 +1,63 @@
+{
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "ignorePatterns": ["dist", "node_modules"],
+    "plugins": [
+        "@typescript-eslint",
+        "license-header",
+        "simple-import-sort",
+        "unused-imports",
+        "path-alias",
+        "prettier"
+    ],
+    "settings": {
+        "import/resolver": {
+            "alias": {
+                "map": []
+            }
+        }
+    },
+    "rules": {
+        "license-header/header": ["error", "scripts/header.txt"],
+        "eqeqeq": ["error", "always", { "null": "ignore" }],
+        "spaced-comment": ["error", "always", { "markers": ["!"] }],
+        "yoda": "error",
+        "prefer-destructuring": ["error", { "object": true, "array": false }],
+        "operator-assignment": ["error", "always"],
+        "no-useless-computed-key": "error",
+        "no-unneeded-ternary": ["error", { "defaultAssignment": false }],
+        "no-invalid-regexp": "error",
+        "no-constant-condition": ["error", { "checkLoops": false }],
+        "no-duplicate-imports": "error",
+        "no-extra-semi": "error",
+        "dot-notation": "error",
+        "no-useless-escape": "error",
+        "no-fallthrough": "error",
+        "for-direction": "error",
+        "no-async-promise-executor": "error",
+        "no-cond-assign": "error",
+        "no-dupe-else-if": "error",
+        "no-duplicate-case": "error",
+        "no-irregular-whitespace": "error",
+        "no-loss-of-precision": "error",
+        "no-misleading-character-class": "error",
+        "no-prototype-builtins": "error",
+        "no-regex-spaces": "error",
+        "no-shadow-restricted-names": "error",
+        "no-unexpected-multiline": "error",
+        "no-unsafe-optional-chaining": "error",
+        "no-useless-backreference": "error",
+        "use-isnan": "error",
+        "prefer-const": "error",
+        "prefer-spread": "error",
+
+        "simple-import-sort/imports": "error",
+        "simple-import-sort/exports": "error",
+
+        "unused-imports/no-unused-imports": "error",
+
+        "path-alias/no-relative": "error",
+
+        "prettier/prettier": "error"
+    }
+}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,28 +1,28 @@
 name: Release

 on:
-  push:
-    tags:
-      - v*
+    push:
+        tags:
+            - v*

 jobs:
-  release:
-    runs-on: ${{ matrix.os }}
+    release:
+        runs-on: ${{ matrix.os }}

-    strategy:
-      matrix:
-        os: [macos-latest, ubuntu-latest, windows-latest]
+        strategy:
+            matrix:
+                os: [macos-latest, ubuntu-latest, windows-latest]

-    steps:
-      - name: Check out Git repository
-        uses: actions/checkout@v3
+        steps:
+            - name: Check out Git repository
+              uses: actions/checkout@v3

-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 18

-      - name: Run Electron Builder
-        uses: samuelmeuli/action-electron-builder@e4b12cd06ddf023422f1ac4e39632bd76f6e6928
-        with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          RELEASE: true
+            - name: Run Electron Builder
+              uses: samuelmeuli/action-electron-builder@e4b12cd06ddf023422f1ac4e39632bd76f6e6928
+              with:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+                  RELEASE: true
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -0,0 +1,32 @@
+name: test
+on:
+    push:
+        branches:
+            - main
+    pull_request:
+        branches:
+            - main
+jobs:
+    test:
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: actions/checkout@v3
+            - uses: pnpm/action-setup@v2 # Install pnpm using packageManager key in package.json
+
+            - name: Use Node.js 18
+              uses: actions/setup-node@v3
+              with:
+                  node-version: 18
+                  cache: "pnpm"
+
+            - name: Install dependencies
+              run: pnpm install --frozen-lockfile
+
+            - name: Run tests
+              run: pnpm test
+
+            - name: Test if it compiles
+              run: |
+                  pnpm build
+                  pnpm build --dev
--- a/.github/workflows/winget-submission.yml
+++ b/.github/workflows/winget-submission.yml
@@ -0,0 +1,25 @@
+name: Submit to Winget Community Repo
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        type: string
+        description: The release tag to submit
+        required: true
+
+jobs:
+  winget:
+    name: Publish winget package
+    runs-on: ubuntu-latest
+    steps:
+      - name: Submit package to Winget Community Repo
+        uses: vedantmgoyal2009/winget-releaser@e68d386d5d6a1cef8cb0fb5e62b77ebcb83e7d58 # v2
+        with:
+          identifier: Vencord.Vesktop
+          token: ${{ secrets.WINGET_PAT }}
+          installers-regex: '\.exe$'
+          release-tag: ${{ inputs.tag || github.event.release.tag_name }}
+          fork-user: shiggybot
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,6 @@
 dist
 node_modules
+.env
+.DS_Store
+.idea/
+.pnpm-store/
--- a/.prettierrc.yaml
+++ b/.prettierrc.yaml
@@ -5,4 +5,4 @@ trailingComma: none
 bracketSpacing: true
 arrowParens: avoid
 useTabs: false
-endOfLine: auto
+endOfLine: lf
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,25 @@
+{
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+        "source.fixAll.eslint": true
+    },
+    "[typescript]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[javascript]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[typescriptreact]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[javascriptreact]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[json]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[jsonc]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "cSpell.words": ["Vesktop"]
+}
--- a/README.md
+++ b/README.md
@@ -1,42 +1,51 @@
-# Vencord Desktop
+# Vesktop

-A standalone Electron app that loads Discord & Vencord
+Vesktop is a cross platform desktop app aiming to give you a snappier Discord experience with [Vencord](https://github.com/Vendicated/Vencord) pre-installed

-Vencord Desktop is currently in very early alpha. Bug reports, feature requests & contributions are highly appreciated!!
+**Not yet supported**:
+- Global Keybinds
+
+Bug reports, feature requests & contributions are highly appreciated!!
+
+![image](https://user-images.githubusercontent.com/45497981/235024615-94565eaf-f412-4384-a3f5-d8cde7458f6d.png)

 ## Installing

 ### Windows

-Download and run Vencord-Desktop-Setup-VERSION.exe from [releases](https://github.com/Vencord/Desktop/releases/latest)
+Download and run Vesktop-Setup-VERSION.exe from [releases](https://github.com/Vencord/Vesktop/releases/latest)

 ### Mac

-Download and run Vencord-Desktop-VERSION.dmg from [releases](https://github.com/Vencord/Desktop/releases/latest)
+Download and run Vesktop-VERSION.dmg from [releases](https://github.com/Vencord/Vesktop/releases/latest)

 ### Linux

+#### Arch based
+
+Install [vencord-desktop-git](https://aur.archlinux.org/packages/vencord-desktop-git) from the AUR using your favourite AUR helper, for example [yay](https://github.com/Jguer/yay)
+
 #### Ubuntu/Debian based

-Download Vencord-Desktop-VERSION.deb from [releases](https://github.com/Vencord/Desktop/releases/latest)
+Download Vesktop-VERSION.deb from [releases](https://github.com/Vencord/Vesktop/releases/latest)

 #### Fedora/RHEL based

-Download Vencord-Desktop-VERSION.rpm from [releases](https://github.com/Vencord/Desktop/releases/latest)
+Download Vesktop-VERSION.rpm from [releases](https://github.com/Vencord/Vesktop/releases/latest)

 #### Other

-Either download Vencord-Desktop-VERSION.AppImage and just run it directly or grab Vencord-Desktop-VERSION.tar.gz, extract it somewhere and run `vencorddesktop`.
+Either download Vesktop-VERSION.AppImage and just run it directly or grab Vesktop-VERSION.tar.gz, extract it somewhere and run `vencorddesktop`.

-An AUR package and flatpak are planned, if you want packages for other repos, feel free to create them and they can be linked as unofficial here
+A flatpak is planned, if you want packages for other repos, feel free to create them and they can be linked as unofficial here

 ## Building

 Packaging will create builds in the dist/ folder. You can then install them like mentioned above or distribute them

 ```sh
-git clone https://github.com/Vencord/Desktop
-cd Desktop
+git clone https://github.com/Vencord/Vesktop
+cd Vesktop

 # Install Dependencies
 pnpm i
@@ -46,6 +55,8 @@ pnpm start

 # Or package
 pnpm package
+# Or only build the pacman target
+pnpm package --linux pacman
 # Or package to a directory only
 pnpm package:dir
 ```
--- a/build/icon.icns
+++ b/build/icon.icns
--- a/package.json
+++ b/package.json
@@ -1,31 +1,66 @@
 {
    "name": "VencordDesktop",
-    "version": "0.1.3",
+    "version": "0.4.3",
    "private": true,
    "description": "",
    "keywords": [],
+    "homepage": "https://vencord.dev/",
    "license": "GPL-3.0",
    "author": "Vendicated <vendicated@riseup.net>",
    "main": "dist/js/main.js",
    "scripts": {
-        "build": "tsx scripts/build.mts",
+        "build": "tsx scripts/build/build.mts",
+        "build:dev": "pnpm build --dev",
        "package": "pnpm build && electron-builder",
        "package:dir": "pnpm build && electron-builder --dir",
+        "lint": "eslint . --ext .js,.jsx,.ts,.tsx,.mts,.mjs",
+        "lint:fix": "pnpm lint --fix",
        "start": "pnpm build && electron .",
-        "start:watch": "tsx scripts/startWatch.mts",
-        "test": "echo \"Error: no test specified\" && exit 1",
+        "start:dev": "pnpm build:dev && electron .",
+        "start:watch": "pnpm build:dev && tsx scripts/startWatch.mts",
+        "test": "pnpm lint && pnpm testTypes",
+        "testTypes": "tsc --noEmit",
        "watch": "pnpm build --watch"
    },
+    "dependencies": {
+        "arrpc": "github:OpenAsar/arrpc#89f4da610ccfac93f461826a446a17cd3b23953d"
+    },
+    "optionalDependencies": {
+        "@vencord/venmic": "^1.7.0"
+    },
    "devDependencies": {
-        "@types/node": "^18.15.11",
-        "electron": "^23.2.0",
-        "electron-builder": "^23.6.0",
-        "esbuild": "^0.17.14",
-        "tsx": "^3.12.6",
-        "typescript": "^5.0.2"
+        "@fal-works/esbuild-plugin-global-externals": "^2.1.2",
+        "@types/node": "^20.8.4",
+        "@types/react": "^18.2.28",
+        "@typescript-eslint/eslint-plugin": "^6.7.5",
+        "@typescript-eslint/parser": "^6.7.5",
+        "@vencord/types": "^0.1.2",
+        "dotenv": "^16.3.1",
+        "electron": "^27.0.0",
+        "electron-builder": "^24.6.4",
+        "esbuild": "^0.19.4",
+        "eslint": "^8.51.0",
+        "eslint-config-prettier": "^9.0.0",
+        "eslint-import-resolver-alias": "^1.1.2",
+        "eslint-plugin-license-header": "^0.6.0",
+        "eslint-plugin-path-alias": "^1.0.0",
+        "eslint-plugin-prettier": "^5.0.1",
+        "eslint-plugin-simple-import-sort": "^10.0.0",
+        "eslint-plugin-unused-imports": "^3.0.0",
+        "prettier": "^3.0.3",
+        "source-map-support": "^0.5.21",
+        "tsx": "^3.13.0",
+        "type-fest": "^4.4.0",
+        "typescript": "^5.2.2"
+    },
+    "packageManager": "pnpm@8.6.11",
+    "engines": {
+        "node": ">=18",
+        "pnpm": ">=8"
    },
    "build": {
        "appId": "dev.vencord.desktop",
+        "productName": "Vesktop",
        "files": [
            "!*",
            "dist/js",
@@ -33,24 +68,81 @@
            "package.json",
            "LICENSE"
        ],
+        "beforePack": "scripts/build/sandboxFix.js",
        "linux": {
+            "icon": "build/icon.icns",
            "category": "Network",
-            "maintainer": "vendicated+vencord-desktop@riseup.net",
+            "maintainer": "vendicated+vesktop@riseup.net",
            "target": [
-                "deb",
-                "tar.gz",
-                "rpm",
-                "AppImage"
-            ]
+                {
+                    "target": "deb",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
+                },
+                {
+                    "target": "tar.gz",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
+                },
+                {
+                    "target": "rpm",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
+                },
+                {
+                    "target": "AppImage",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
+                }
+            ],
+            "desktop": {
+                "Name": "Vesktop",
+                "GenericName": "Internet Messenger",
+                "Type": "Application",
+                "Categories": "Network;InstantMessaging;Chat;",
+                "Keywords": "discord;vencord;electron;chat;",
+                "WMClass": "VencordDesktop",
+                "StartupWMClass": "VencordDesktop"
+            }
        },
        "mac": {
-            "category": "Network"
+            "target": [
+                {
+                    "target": "default",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
+                }
+            ],
+            "category": "Network",
+            "extendInfo": {
+                "NSMicrophoneUsageDescription": "This app needs access to the microphone",
+                "NSCameraUsageDescription": "This app needs access to the camera",
+                "com.apple.security.device.audio-input": true,
+                "com.apple.security.device.camera": true
+            }
        },
        "nsis": {
-            "allowToChangeInstallationDirectory": true,
            "include": "build/installer.nsh",
            "oneClick": false
        },
-        "productName": "Vencord Desktop"
+        "win": {
+            "target": [
+                "nsis",
+                "zip"
+            ]
+        },
+        "publish": {
+            "provider": "github"
+        }
    }
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/scripts/build.mts
+++ b/scripts/build.mts
@@ -1,51 +0,0 @@
-import { BuildContext, BuildOptions, context } from "esbuild";
-
-const CommonOpts: BuildOptions = {
-    minify: true,
-    bundle: true,
-    sourcemap: "linked",
-    logLevel: "info"
-};
-
-const NodeCommonOpts: BuildOptions = {
-    ...CommonOpts,
-    format: "cjs",
-    platform: "node",
-    external: ["electron"],
-    target: ["esnext"],
-};
-
-const contexts = [] as BuildContext[];
-async function createContext(options: BuildOptions) {
-    contexts.push(await context(options));
-}
-
-await Promise.all([
-    createContext({
-        ...NodeCommonOpts,
-        entryPoints: ["src/main/index.ts"],
-        outfile: "dist/js/main.js"
-    }),
-    createContext({
-        ...NodeCommonOpts,
-        entryPoints: ["src/preload/index.ts"],
-        outfile: "dist/js/preload.js"
-    }),
-    createContext({
-        ...CommonOpts,
-        entryPoints: ["src/renderer/index.ts"],
-        outfile: "dist/js/renderer.js",
-        format: "iife",
-    })
-]);
-
-const watch = process.argv.includes("--watch");
-
-if (watch) {
-    await Promise.all(contexts.map(ctx => ctx.watch()));
-} else {
-    await Promise.all(contexts.map(async ctx => {
-        await ctx.rebuild();
-        await ctx.dispose();
-    }));
-}
--- a/scripts/build/build.mts
+++ b/scripts/build/build.mts
@@ -0,0 +1,100 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { BuildContext, BuildOptions, context } from "esbuild";
+import { copyFile } from "fs/promises";
+
+import vencordDep from "./vencordDep.mjs";
+
+const isDev = process.argv.includes("--dev");
+
+const CommonOpts: BuildOptions = {
+    minify: !isDev,
+    bundle: true,
+    sourcemap: "linked",
+    logLevel: "info"
+};
+
+const NodeCommonOpts: BuildOptions = {
+    ...CommonOpts,
+    format: "cjs",
+    platform: "node",
+    external: ["electron"],
+    target: ["esnext"],
+    define: {
+        IS_DEV: JSON.stringify(isDev)
+    }
+};
+
+const contexts = [] as BuildContext[];
+async function createContext(options: BuildOptions) {
+    contexts.push(await context(options));
+}
+
+async function copyVenmic() {
+    if (process.platform !== "linux") return;
+
+    return Promise.all([
+        copyFile(
+            "./node_modules/@vencord/venmic/prebuilds/venmic-addon-linux-x64/node-napi-v7.node",
+            "./static/dist/venmic-x64.node"
+        ),
+        copyFile(
+            "./node_modules/@vencord/venmic/prebuilds/venmic-addon-linux-arm64/node-napi-v7.node",
+            "./static/dist/venmic-arm64.node"
+        )
+    ]).catch(() => console.warn("Failed to copy venmic. Building without venmic support"));
+}
+
+await Promise.all([
+    copyVenmic(),
+    createContext({
+        ...NodeCommonOpts,
+        entryPoints: ["src/main/index.ts"],
+        outfile: "dist/js/main.js",
+        footer: { js: "//# sourceURL=VCDMain" }
+    }),
+    createContext({
+        ...NodeCommonOpts,
+        entryPoints: ["src/preload/index.ts"],
+        outfile: "dist/js/preload.js",
+        footer: { js: "//# sourceURL=VCDPreload" }
+    }),
+    createContext({
+        ...NodeCommonOpts,
+        entryPoints: ["src/updater/preload.ts"],
+        outfile: "dist/js/updaterPreload.js",
+        footer: { js: "//# sourceURL=VCDUpdaterPreload" }
+    }),
+    createContext({
+        ...CommonOpts,
+        globalName: "Vesktop",
+        entryPoints: ["src/renderer/index.ts"],
+        outfile: "dist/js/renderer.js",
+        format: "iife",
+        inject: ["./scripts/build/injectReact.mjs"],
+        jsxFactory: "VencordCreateElement",
+        jsxFragment: "VencordFragment",
+        // Work around https://github.com/evanw/esbuild/issues/2460
+        tsconfig: "./scripts/build/tsconfig.esbuild.json",
+        external: ["@vencord/types/*"],
+        plugins: [vencordDep],
+        footer: { js: "//# sourceURL=VCDRenderer" }
+    })
+]);
+
+const watch = process.argv.includes("--watch");
+
+if (watch) {
+    await Promise.all(contexts.map(ctx => ctx.watch()));
+} else {
+    await Promise.all(
+        contexts.map(async ctx => {
+            await ctx.rebuild();
+            await ctx.dispose();
+        })
+    );
+}
--- a/scripts/build/injectReact.mjs
+++ b/scripts/build/injectReact.mjs
@@ -0,0 +1,9 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+export const VencordFragment = /* #__PURE__*/ Symbol.for("react.fragment");
+export let VencordCreateElement = (...args) =>
+    (VencordCreateElement = Vencord.Webpack.Common.React.createElement)(...args);
--- a/scripts/build/sandboxFix.js
+++ b/scripts/build/sandboxFix.js
@@ -0,0 +1,74 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+// Based on https://github.com/gergof/electron-builder-sandbox-fix/blob/master/lib/index.js
+
+const fs = require("fs/promises");
+const path = require("path");
+let isApplied = false;
+
+const hook = async () => {
+    if (isApplied) return;
+    isApplied = true;
+    if (process.platform !== "linux") {
+        // this fix is only required on linux
+        return;
+    }
+    const AppImageTarget = require("app-builder-lib/out/targets/AppImageTarget");
+    const oldBuildMethod = AppImageTarget.default.prototype.build;
+    AppImageTarget.default.prototype.build = async function (...args) {
+        console.log("Running AppImage builder hook", args);
+        const oldPath = args[0];
+        const newPath = oldPath + "-appimage-sandbox-fix";
+        // just in case
+        try {
+            await fs.rm(newPath, {
+                recursive: true
+            });
+        } catch {}
+
+        console.log("Copying to apply appimage fix", oldPath, newPath);
+        await fs.cp(oldPath, newPath, {
+            recursive: true
+        });
+        args[0] = newPath;
+
+        const executable = path.join(newPath, this.packager.executableName);
+
+        const loaderScript = `
+#!/usr/bin/env bash
+
+SCRIPT_DIR="$( cd "$( dirname "\${BASH_SOURCE[0]}" )" && pwd )"
+IS_STEAMOS=0
+
+if [[ "$SteamOS" == "1" && "$SteamGamepadUI" == "1" ]]; then
+    echo "Running Vesktop on SteamOS, disabling sandbox"
+    IS_STEAMOS=1
+fi
+
+exec "$SCRIPT_DIR/${this.packager.executableName}.bin" "$([ "$IS_STEAMOS" == 1 ] && echo '--no-sandbox')" "$@"
+                `.trim();
+
+        try {
+            await fs.rename(executable, executable + ".bin");
+            await fs.writeFile(executable, loaderScript);
+            await fs.chmod(executable, 0o755);
+        } catch (e) {
+            console.error("failed to create loder for sandbox fix: " + e.message);
+            throw new Error("Failed to create loader for sandbox fix");
+        }
+
+        const ret = await oldBuildMethod.apply(this, args);
+
+        await fs.rm(newPath, {
+            recursive: true
+        });
+
+        return ret;
+    };
+};
+
+module.exports = hook;
--- a/scripts/build/tsconfig.esbuild.json
+++ b/scripts/build/tsconfig.esbuild.json
@@ -0,0 +1,7 @@
+// Work around https://github.com/evanw/esbuild/issues/2460
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "jsx": "react"
+    }
+}
--- a/scripts/build/vencordDep.mts
+++ b/scripts/build/vencordDep.mts
@@ -0,0 +1,38 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { globalExternalsWithRegExp } from "@fal-works/esbuild-plugin-global-externals";
+
+const names = {
+    webpack: "Vencord.Webpack",
+    "webpack/common": "Vencord.Webpack.Common",
+    utils: "Vencord.Util",
+    api: "Vencord.Api",
+    "api/settings": "Vencord",
+    components: "Vencord.Components"
+};
+
+export default globalExternalsWithRegExp({
+    getModuleInfo(modulePath) {
+        const path = modulePath.replace("@vencord/types/", "");
+        let varName = names[path];
+        if (!varName) {
+            const altMapping = names[path.split("/")[0]];
+            if (!altMapping) throw new Error("Unknown module path: " + modulePath);
+
+            varName =
+                altMapping +
+                "." +
+                // @ts-ignore
+                path.split("/")[1].replaceAll("/", ".");
+        }
+        return {
+            varName,
+            type: "cjs"
+        };
+    },
+    modulePathFilter: /^@vencord\/types.+$/
+});
--- a/scripts/header.txt
+++ b/scripts/header.txt
@@ -0,0 +1,5 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
--- a/scripts/start.ts
+++ b/scripts/start.ts
@@ -0,0 +1,11 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import "./utils/dotenv";
+
+import { spawnNodeModuleBin } from "./utils/spawn.mjs";
+
+spawnNodeModuleBin("electron", [".", ...(process.env.ELECTRON_LAUNCH_FLAGS?.split(" ") ?? [])]);
--- a/scripts/startWatch.mts
+++ b/scripts/startWatch.mts
@@ -1,15 +1,10 @@
-import { spawn as cpSpawn, SpawnOptions } from "child_process";
-import { join } from "path";
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */

-const EXT = process.platform === "win32" ? ".cmd" : "";
+import "./start";

-const OPTS: SpawnOptions = {
-    stdio: "inherit",
-};
-
-function spawn(bin: string, args: string[]) {
-    cpSpawn(join("node_modules", ".bin", bin + EXT), args, OPTS);
-}
-
-spawn("tsx", ["scripts/build.mts", "--", "--watch"]);
-spawn("electron", ["."]);
+import { spawnNodeModuleBin } from "./utils/spawn.mjs";
+spawnNodeModuleBin("tsx", ["scripts/build/build.mts", "--", "--watch", "--dev"]);
--- a/scripts/utils/dotenv.ts
+++ b/scripts/utils/dotenv.ts
@@ -0,0 +1,9 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { config } from "dotenv";
+
+config();
--- a/scripts/utils/spawn.mts
+++ b/scripts/utils/spawn.mts
@@ -0,0 +1,18 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { spawn as spaaawn, SpawnOptions } from "child_process";
+import { join } from "path";
+
+const EXT = process.platform === "win32" ? ".cmd" : "";
+
+const OPTS: SpawnOptions = {
+    stdio: "inherit"
+};
+
+export function spawnNodeModuleBin(bin: string, args: string[]) {
+    spaaawn(join("node_modules", ".bin", bin + EXT), args, OPTS);
+}
--- a/src/globals.d.ts
+++ b/src/globals.d.ts
@@ -1,8 +1,15 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 declare global {
-    export var VencordDesktop: typeof import("./preload/VencordDesktop").VencordDesktop;
-    // TODO
-    export var Vencord: any;
-    export var vcdLS: typeof localStorage;
+    export var VesktopNative: typeof import("preload/VesktopNative").VesktopNative;
+    export var Vesktop: typeof import("renderer/index");
+    export var VCDP: any;
+
+    export var IS_DEV: boolean;
 }

-export { };
+export {};
--- a/src/main/about.ts
+++ b/src/main/about.ts
@@ -1,18 +1,28 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import { BrowserWindow } from "electron";
 import { join } from "path";
-import { ICON_PATH, STATIC_DIR } from "shared/paths";
+import { ICON_PATH, VIEW_DIR } from "shared/paths";
+
 import { makeLinksOpenExternally } from "./utils/makeLinksOpenExternally";

 export function createAboutWindow() {
    const about = new BrowserWindow({
        center: true,
        autoHideMenuBar: true,
-        icon: ICON_PATH
+        icon: ICON_PATH,
+        webPreferences: {
+            preload: join(__dirname, "updaterPreload.js")
+        }
    });

    makeLinksOpenExternally(about);

-    about.loadFile(join(STATIC_DIR, "about.html"));
+    about.loadFile(join(VIEW_DIR, "about.html"));

    return about;
 }
--- a/src/main/appBadge.ts
+++ b/src/main/appBadge.ts
@@ -0,0 +1,56 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { app, NativeImage, nativeImage } from "electron";
+import { join } from "path";
+import { BADGE_DIR } from "shared/paths";
+
+const imgCache = new Map<number, NativeImage>();
+function loadBadge(index: number) {
+    const cached = imgCache.get(index);
+    if (cached) return cached;
+
+    const img = nativeImage.createFromPath(join(BADGE_DIR, `${index}.ico`));
+    imgCache.set(index, img);
+
+    return img;
+}
+
+let lastIndex: null | number = -1;
+
+export function setBadgeCount(count: number) {
+    switch (process.platform) {
+        case "linux":
+            if (count === -1) count = 0;
+            app.setBadgeCount(count);
+            break;
+        case "darwin":
+            if (count === 0) {
+                app.dock.setBadge("");
+                break;
+            }
+            app.dock.setBadge(count === -1 ? "•" : count.toString());
+            break;
+        case "win32":
+            const [index, description] = getBadgeIndexAndDescription(count);
+            if (lastIndex === index) break;
+
+            lastIndex = index;
+
+            // circular import shenanigans
+            const { mainWin } = require("./mainWindow") as typeof import("./mainWindow");
+            mainWin.setOverlayIcon(index === null ? null : loadBadge(index), description);
+            break;
+    }
+}
+
+function getBadgeIndexAndDescription(count: number): [number | null, string] {
+    if (count === -1) return [11, "Unread Messages"];
+    if (count === 0) return [null, "No Notifications"];
+
+    const index = Math.max(1, Math.min(count, 10));
+    return [index, `${index} Notification`];
+}
--- a/src/main/arrpc.ts
+++ b/src/main/arrpc.ts
@@ -0,0 +1,38 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import Server from "arrpc";
+import { IpcEvents } from "shared/IpcEvents";
+
+import { mainWin } from "./mainWindow";
+import { Settings } from "./settings";
+
+let server: any;
+
+const inviteCodeRegex = /^(\w|-)+$/;
+
+export async function initArRPC() {
+    if (server || !Settings.store.arRPC) return;
+
+    try {
+        server = await new Server();
+        server.on("activity", (data: any) => mainWin.webContents.send(IpcEvents.ARRPC_ACTIVITY, JSON.stringify(data)));
+        server.on("invite", (invite: string, callback: (valid: boolean) => void) => {
+            invite = String(invite);
+            if (!inviteCodeRegex.test(invite)) return callback(false);
+
+            mainWin.webContents
+                // Safety: Result of JSON.stringify should always be safe to equal
+                // Also, just to be super super safe, invite is regex validated above
+                .executeJavaScript(`Vesktop.openInviteModal(${JSON.stringify(invite)})`)
+                .then(callback);
+        });
+    } catch (e) {
+        console.error("Failed to start arRPC server", e);
+    }
+}
+
+Settings.addChangeListener("arRPC", initArRPC);
--- a/src/main/autoStart.ts
+++ b/src/main/autoStart.ts
@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { app } from "electron";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+
+interface AutoStart {
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+}
+
+function makeAutoStartLinux(): AutoStart {
+    const configDir = process.env.XDG_CONFIG_HOME || join(process.env.HOME!, ".config");
+    const dir = join(configDir, "autostart");
+    const file = join(dir, "vencord.desktop");
+
+    return {
+        isEnabled: () => existsSync(file),
+        enable() {
+            const desktopFile = `
+[Desktop Entry]
+Type=Application
+Version=1.0
+Name=Vencord
+Comment=Vencord autostart script
+Exec=${process.execPath}
+Terminal=false
+StartupNotify=false
+`.trim();
+
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(file, desktopFile);
+        },
+        disable: () => rmSync(file, { force: true })
+    };
+}
+
+const autoStartWindowsMac: AutoStart = {
+    isEnabled: () => app.getLoginItemSettings().openAtLogin,
+    enable: () => app.setLoginItemSettings({ openAtLogin: true }),
+    disable: () => app.setLoginItemSettings({ openAtLogin: false })
+};
+
+export const autoStart = process.platform === "linux" ? makeAutoStartLinux() : autoStartWindowsMac;
--- a/src/main/constants.ts
+++ b/src/main/constants.ts
@@ -1,10 +1,41 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import { app } from "electron";
 import { join } from "path";

-export const DATA_DIR = process.env.VENCORD_USER_DATA_DIR ?? join(app.getPath("userData"), "VencordDesktop");
-export const VENCORD_FILES_DIR = join(DATA_DIR, "vencordDist");
+export const DATA_DIR = process.env.VENCORD_USER_DATA_DIR || join(app.getPath("userData"), "VencordDesktop");
 export const VENCORD_SETTINGS_DIR = join(DATA_DIR, "settings");
 export const VENCORD_QUICKCSS_FILE = join(VENCORD_SETTINGS_DIR, "quickCss.css");
 export const VENCORD_SETTINGS_FILE = join(VENCORD_SETTINGS_DIR, "settings.json");
+export const VENCORD_THEMES_DIR = join(DATA_DIR, "themes");

-export const USER_AGENT = `VencordDesktop/${app.getVersion()} (https://github.com/Vencord/Electron)`;
+// needs to be inline require because of circular dependency
+// as otherwise "DATA_DIR" (which is used by ./settings) will be uninitialised
+export const VENCORD_FILES_DIR =
+    (require("./settings") as typeof import("./settings")).Settings.store.vencordDir || join(DATA_DIR, "vencordDist");
+
+export const USER_AGENT = `Vesktop/${app.getVersion()} (https://github.com/Vencord/Vesktop)`;
+
+// dimensions shamelessly stolen from Discord Desktop :3
+export const MIN_WIDTH = 940;
+export const MIN_HEIGHT = 500;
+export const DEFAULT_WIDTH = 1280;
+export const DEFAULT_HEIGHT = 720;
+
+const UserAgents = {
+    darwin: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+    linux: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+    windows:
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36"
+};
+
+export const UserAgent = UserAgents[process.platform] || UserAgents.windows;
+
+export const enum MessageBoxChoice {
+    Default,
+    Cancel
+}
--- a/src/main/firstLaunch.ts
+++ b/src/main/firstLaunch.ts
@@ -0,0 +1,73 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { app } from "electron";
+import { BrowserWindow } from "electron/main";
+import { copyFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+import { SplashProps } from "shared/browserWinProperties";
+import { ICON_PATH, VIEW_DIR } from "shared/paths";
+
+import { autoStart } from "./autoStart";
+import { DATA_DIR } from "./constants";
+import { createWindows } from "./mainWindow";
+import { Settings } from "./settings";
+import { makeLinksOpenExternally } from "./utils/makeLinksOpenExternally";
+
+interface Data {
+    minimizeToTray: boolean;
+    discordBranch: "stable" | "canary" | "ptb";
+    autoStart: boolean;
+    importSettings: boolean;
+    richPresence: boolean;
+}
+
+export function createFirstLaunchTour() {
+    const win = new BrowserWindow({
+        ...SplashProps,
+        frame: true,
+        autoHideMenuBar: true,
+        height: 470,
+        width: 550,
+        icon: ICON_PATH
+    });
+
+    makeLinksOpenExternally(win);
+
+    win.loadFile(join(VIEW_DIR, "first-launch.html"));
+    win.webContents.addListener("console-message", (_e, _l, msg) => {
+        if (msg === "cancel") return app.exit();
+
+        if (!msg.startsWith("form:")) return;
+        const data = JSON.parse(msg.slice(5)) as Data;
+
+        Settings.store.minimizeToTray = data.minimizeToTray;
+        Settings.store.discordBranch = data.discordBranch;
+        Settings.store.firstLaunch = false;
+        Settings.store.arRPC = data.richPresence;
+
+        if (data.autoStart) autoStart.enable();
+
+        if (data.importSettings) {
+            const from = join(app.getPath("userData"), "..", "Vencord", "settings");
+            const to = join(DATA_DIR, "settings");
+            try {
+                const files = readdirSync(from);
+                mkdirSync(to, { recursive: true });
+
+                for (const file of files) {
+                    copyFileSync(join(from, file), join(to, file));
+                }
+            } catch (e) {
+                console.error("Failed to import settings:", e);
+            }
+        }
+
+        win.close();
+
+        createWindows();
+    });
+}
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -1,31 +1,44 @@
-import { app, BrowserWindow } from 'electron';
-import { createMainWindow } from "./mainWindow";
-import { createSplashWindow } from "./splash";
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */

-import { join } from "path";
-
-import { DATA_DIR, VENCORD_FILES_DIR } from "./constants";
-
-import { once } from "../shared/utils/once";
-import { ensureVencordFiles } from "./utils/vencordLoader";
-
-import { ICON_PATH } from "../shared/paths";
 import "./ipc";
+
+import { app, BrowserWindow } from "electron";
+import { checkUpdates } from "updater/main";
+
+import { DATA_DIR } from "./constants";
+import { createFirstLaunchTour } from "./firstLaunch";
+import { createWindows, mainWin } from "./mainWindow";
+import { registerMediaPermissionsHandler } from "./mediaPermissions";
+import { registerScreenShareHandler } from "./screenShare";
 import { Settings } from "./settings";

+if (IS_DEV) {
+    require("source-map-support").install();
+}
+
 // Make the Vencord files use our DATA_DIR
 process.env.VENCORD_USER_DATA_DIR = DATA_DIR;

-const runVencordMain = once(() => require(join(VENCORD_FILES_DIR, "main.js")));
+function init() {
+    // work around chrome 66 disabling autoplay by default
+    app.commandLine.appendSwitch("autoplay-policy", "no-user-gesture-required");

-let mainWin: BrowserWindow | null = null;
+    // WinRetrieveSuggestionsOnlyOnDemand: Work around electron 13 bug w/ async spellchecking on Windows.
+    // HardwareMediaKeyHandling,MediaSessionService: Prevent Discord from registering as a media service.
+    //
+    // WidgetLayering (Vencord Added): Fix DevTools context menus https://github.com/electron/electron/issues/38790
+    app.commandLine.appendSwitch(
+        "disable-features",
+        "WinRetrieveSuggestionsOnlyOnDemand,HardwareMediaKeyHandling,MediaSessionService,WidgetLayering"
+    );

-if (!app.requestSingleInstanceLock()) {
-    console.log("Vencord Desktop is already running. Quitting...");
-    app.quit();
-} else {
-    app.on("second-instance", () => {
-        if (mainWin) {
+    app.on("second-instance", (_event, _cmdLine, _cwd, data: any) => {
+        if (data.IS_DEV) app.quit();
+        else if (mainWin) {
            if (mainWin.isMinimized()) mainWin.restore();
            if (!mainWin.isVisible()) mainWin.show();
            mainWin.focus();
@@ -33,38 +46,40 @@ if (!app.requestSingleInstanceLock()) {
    });

    app.whenReady().then(async () => {
-        if (process.platform === "win32")
-            app.setAppUserModelId("dev.vencord.desktop");
-        else if (process.platform === "darwin")
-            app.dock.setIcon(ICON_PATH);
+        checkUpdates();
+        if (process.platform === "win32") app.setAppUserModelId("dev.vencord.desktop");

-        createWindows();
+        registerScreenShareHandler();
+        registerMediaPermissionsHandler();

-        app.on('activate', () => {
+        bootstrap();
+
+        app.on("activate", () => {
            if (BrowserWindow.getAllWindows().length === 0) createWindows();
        });
    });
 }

-async function createWindows() {
-    const splash = createSplashWindow();
+if (!app.requestSingleInstanceLock({ IS_DEV })) {
+    if (IS_DEV) {
+        console.log("Vesktop is already running. Quitting previous instance...");
+        init();
+    } else {
+        console.log("Vesktop is already running. Quitting...");
+        app.quit();
+    }
+} else {
+    init();
+}

-    await ensureVencordFiles();
-    runVencordMain();
-
-    mainWin = createMainWindow();
-
-    mainWin.once("ready-to-show", () => {
-        splash.destroy();
-        mainWin!.show();
-
-        if (Settings.maximized) {
-            mainWin!.maximize();
-        }
-    });
+async function bootstrap() {
+    if (!Object.hasOwn(Settings.store, "firstLaunch")) {
+        createFirstLaunchTour();
+    } else {
+        createWindows();
+    }
 }

 app.on("window-all-closed", () => {
-    if (process.platform !== "darwin")
-        app.quit();
+    if (process.platform !== "darwin") app.quit();
 });
--- a/src/main/ipc.ts
+++ b/src/main/ipc.ts
@@ -1,51 +1,141 @@
-import { app, ipcMain, shell } from "electron";
-import { readFileSync, watch } from "fs";
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+if (process.platform === "linux") import("./virtmic");
+
+import { execFile } from "child_process";
+import { app, BrowserWindow, dialog, RelaunchOptions, session, shell } from "electron";
+import { mkdirSync, readFileSync, watch } from "fs";
 import { open, readFile } from "fs/promises";
+import { release } from "os";
 import { join } from "path";
 import { debounce } from "shared/utils/debounce";
-import { FOCUS, GET_RENDERER_SCRIPT, GET_RENDERER_STYLES, GET_SETTINGS, GET_VENCORD_PRELOAD_FILE, RELAUNCH, SET_SETTINGS, SHOW_ITEM_IN_FOLDER } from "../shared/IpcEvents";
-import { VENCORD_FILES_DIR, VENCORD_QUICKCSS_FILE } from "./constants";
+
+import { IpcEvents } from "../shared/IpcEvents";
+import { setBadgeCount } from "./appBadge";
+import { autoStart } from "./autoStart";
+import { VENCORD_FILES_DIR, VENCORD_QUICKCSS_FILE, VENCORD_THEMES_DIR } from "./constants";
 import { mainWin } from "./mainWindow";
-import { PlainSettings, setSettings } from "./settings";
+import { Settings } from "./settings";
+import { handle, handleSync } from "./utils/ipcWrappers";
+import { isValidVencordInstall } from "./utils/vencordLoader";

-ipcMain.on(GET_VENCORD_PRELOAD_FILE, e => {
-    e.returnValue = join(VENCORD_FILES_DIR, "preload.js");
+handleSync(IpcEvents.GET_VENCORD_PRELOAD_FILE, () => join(VENCORD_FILES_DIR, "vencordDesktopPreload.js"));
+handleSync(IpcEvents.GET_VENCORD_RENDERER_SCRIPT, () =>
+    readFileSync(join(VENCORD_FILES_DIR, "vencordDesktopRenderer.js"), "utf-8")
+);
+
+handleSync(IpcEvents.GET_RENDERER_SCRIPT, () => readFileSync(join(__dirname, "renderer.js"), "utf-8"));
+handleSync(IpcEvents.GET_RENDERER_CSS_FILE, () => join(__dirname, "renderer.css"));
+
+handleSync(IpcEvents.GET_SETTINGS, () => Settings.plain);
+handleSync(IpcEvents.GET_VERSION, () => app.getVersion());
+
+handleSync(
+    IpcEvents.SUPPORTS_WINDOWS_TRANSPARENCY,
+    () => process.platform === "win32" && Number(release().split(".").pop()) >= 22621
+);
+
+handleSync(IpcEvents.AUTOSTART_ENABLED, () => autoStart.isEnabled());
+handle(IpcEvents.ENABLE_AUTOSTART, autoStart.enable);
+handle(IpcEvents.DISABLE_AUTOSTART, autoStart.disable);
+
+handle(IpcEvents.SET_SETTINGS, (_, settings: typeof Settings.store, path?: string) => {
+    Settings.setData(settings, path);
 });

-ipcMain.on(GET_RENDERER_SCRIPT, e => {
-    e.returnValue = readFileSync(join(__dirname, "renderer.js"), "utf-8");
-});
-
-ipcMain.handle(GET_RENDERER_STYLES, () => readFile(join(__dirname, "renderer.css"), "utf-8"));
-
-ipcMain.on(GET_SETTINGS, e => {
-    e.returnValue = PlainSettings;
-});
-
-ipcMain.handle(SET_SETTINGS, (_, settings) => {
-    setSettings(settings);
-});
-
-ipcMain.handle(RELAUNCH, () => {
-    app.relaunch();
+handle(IpcEvents.RELAUNCH, () => {
+    const options: RelaunchOptions = {
+        args: process.argv.slice(1).concat(["--relaunch"])
+    };
+    if (app.isPackaged && process.env.APPIMAGE) {
+        execFile(process.env.APPIMAGE, options.args);
+    } else {
+        app.relaunch(options);
+    }
    app.exit();
 });

-ipcMain.handle(SHOW_ITEM_IN_FOLDER, (_, path) => {
+handle(IpcEvents.SHOW_ITEM_IN_FOLDER, (_, path) => {
    shell.showItemInFolder(path);
 });

-ipcMain.handle(FOCUS, () => {
-    mainWin?.focus();
+handle(IpcEvents.FOCUS, () => {
+    if (process.platform === "win32") mainWin.minimize(); // Windows is weird
+
+    mainWin.restore();
+    mainWin.show();
 });

+handle(IpcEvents.CLOSE, e => {
+    (BrowserWindow.fromWebContents(e.sender) ?? e.sender).close();
+});
+
+handle(IpcEvents.MINIMIZE, e => {
+    mainWin.minimize();
+});
+
+handle(IpcEvents.MAXIMIZE, e => {
+    if (mainWin.isMaximized()) {
+        mainWin.unmaximize();
+    } else {
+        mainWin.maximize();
+    }
+});
+
+handle(IpcEvents.SPELLCHECK_SET_LANGUAGES, (_, languages: string[]) => {
+    const ses = session.defaultSession;
+
+    const available = ses.availableSpellCheckerLanguages;
+    const applicable = languages.filter(l => available.includes(l)).slice(0, 3);
+    if (applicable.length) ses.setSpellCheckerLanguages(applicable);
+});
+
+handle(IpcEvents.SPELLCHECK_REPLACE_MISSPELLING, (e, word: string) => {
+    e.sender.replaceMisspelling(word);
+});
+
+handle(IpcEvents.SPELLCHECK_ADD_TO_DICTIONARY, (e, word: string) => {
+    e.sender.session.addWordToSpellCheckerDictionary(word);
+});
+
+handle(IpcEvents.SELECT_VENCORD_DIR, async () => {
+    const res = await dialog.showOpenDialog(mainWin!, {
+        properties: ["openDirectory"]
+    });
+    if (!res.filePaths.length) return "cancelled";
+
+    const dir = res.filePaths[0];
+    if (!isValidVencordInstall(dir)) return "invalid";
+
+    return dir;
+});
+
+handle(IpcEvents.SET_BADGE_COUNT, (_, count: number) => setBadgeCount(count));
+
 function readCss() {
    return readFile(VENCORD_QUICKCSS_FILE, "utf-8").catch(() => "");
 }

 open(VENCORD_QUICKCSS_FILE, "a+").then(fd => {
    fd.close();
-    watch(VENCORD_QUICKCSS_FILE, { persistent: false }, debounce(async () => {
-        mainWin?.webContents.postMessage("VencordQuickCssUpdate", await readCss());
-    }, 50));
+    watch(
+        VENCORD_QUICKCSS_FILE,
+        { persistent: false },
+        debounce(async () => {
+            mainWin?.webContents.postMessage("VencordQuickCssUpdate", await readCss());
+        }, 50)
+    );
 });
+
+mkdirSync(VENCORD_THEMES_DIR, { recursive: true });
+watch(
+    VENCORD_THEMES_DIR,
+    { persistent: false },
+    debounce(() => {
+        mainWin?.webContents.postMessage("VencordThemeUpdate", void 0);
+    })
+);
--- a/src/main/mainWindow.ts
+++ b/src/main/mainWindow.ts
@@ -1,12 +1,49 @@
-import { BrowserWindow, BrowserWindowConstructorOptions, Menu, Tray, app } from "electron";
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import {
+    app,
+    BrowserWindow,
+    BrowserWindowConstructorOptions,
+    dialog,
+    Menu,
+    MenuItemConstructorOptions,
+    nativeTheme,
+    Tray
+} from "electron";
+import { rm } from "fs/promises";
 import { join } from "path";
+import { IpcEvents } from "shared/IpcEvents";
+import { isTruthy } from "shared/utils/guards";
+import { once } from "shared/utils/once";
+import type { SettingsStore } from "shared/utils/SettingsStore";
+
 import { ICON_PATH } from "../shared/paths";
 import { createAboutWindow } from "./about";
-import { Settings } from "./settings";
+import { initArRPC } from "./arrpc";
+import {
+    DATA_DIR,
+    DEFAULT_HEIGHT,
+    DEFAULT_WIDTH,
+    MessageBoxChoice,
+    MIN_HEIGHT,
+    MIN_WIDTH,
+    UserAgent,
+    VENCORD_FILES_DIR
+} from "./constants";
+import { Settings, VencordSettings } from "./settings";
+import { createSplashWindow } from "./splash";
 import { makeLinksOpenExternally } from "./utils/makeLinksOpenExternally";
-import { downloadVencordFiles } from "./utils/vencordLoader";
+import { applyDeckKeyboardFix, askToApplySteamLayout, isDeckGameMode } from "./utils/steamOS";
+import { downloadVencordFiles, ensureVencordFiles } from "./utils/vencordLoader";

 let isQuitting = false;
+let tray: Tray;
+
+applyDeckKeyboardFix();

 app.on("before-quit", () => {
    isQuitting = true;
@@ -14,6 +51,27 @@ app.on("before-quit", () => {

 export let mainWin: BrowserWindow;

+function makeSettingsListenerHelpers<O extends object>(o: SettingsStore<O>) {
+    const listeners = new Map<(data: any) => void, PropertyKey>();
+
+    const addListener: typeof o.addChangeListener = (path, cb) => {
+        listeners.set(cb, path);
+        o.addChangeListener(path, cb);
+    };
+    const removeAllListeners = () => {
+        for (const [listener, path] of listeners) {
+            o.removeChangeListener(path as any, listener);
+        }
+
+        listeners.clear();
+    };
+
+    return [addListener, removeAllListeners] as const;
+}
+
+const [addSettingsListener, removeSettingsListeners] = makeSettingsListenerHelpers(Settings);
+const [addVencordSettingsListener, removeVencordSettingsListeners] = makeSettingsListenerHelpers(VencordSettings);
+
 function initTray(win: BrowserWindow) {
    const trayMenu = Menu.buildFromTemplate([
        {
@@ -35,6 +93,12 @@ function initTray(win: BrowserWindow) {
                app.quit();
            }
        },
+        {
+            label: "Reset Vesktop",
+            async click() {
+                await clearData(win);
+            }
+        },
        {
            type: "separator"
        },
@@ -46,7 +110,7 @@ function initTray(win: BrowserWindow) {
            }
        },
        {
-            label: "Quit Vencord Desktop",
+            label: "Quit Vesktop",
            click() {
                isQuitting = true;
                app.quit();
@@ -54,8 +118,8 @@ function initTray(win: BrowserWindow) {
        }
    ]);

-    const tray = new Tray(ICON_PATH);
-    tray.setToolTip("Vencord Desktop");
+    tray = new Tray(ICON_PATH);
+    tray.setToolTip("Vesktop");
    tray.setContextMenu(trayMenu);
    tray.on("click", () => win.show());

@@ -68,183 +132,339 @@ function initTray(win: BrowserWindow) {
    });
 }

+async function clearData(win: BrowserWindow) {
+    const { response } = await dialog.showMessageBox(win, {
+        message: "Are you sure you want to reset Vesktop?",
+        detail: "This will log you out, clear caches and reset all your settings!\n\nVesktop will automatically restart after this operation.",
+        buttons: ["Yes", "No"],
+        cancelId: MessageBoxChoice.Cancel,
+        defaultId: MessageBoxChoice.Default,
+        type: "warning"
+    });
+
+    if (response === MessageBoxChoice.Cancel) return;
+
+    win.close();
+
+    await win.webContents.session.clearStorageData();
+    await win.webContents.session.clearCache();
+    await win.webContents.session.clearCodeCaches({});
+    await rm(DATA_DIR, { force: true, recursive: true });
+
+    app.relaunch();
+    app.quit();
+}
+
+type MenuItemList = Array<MenuItemConstructorOptions | false>;
+
 function initMenuBar(win: BrowserWindow) {
-    console.log(process.platform);
-    const menu = Menu.buildFromTemplate([
+    const isWindows = process.platform === "win32";
+    const isDarwin = process.platform === "darwin";
+    const wantCtrlQ = !isWindows || VencordSettings.store.winCtrlQ;
+
+    const subMenu = [
        {
-            label: "Vencord Desktop",
-            submenu: [
-                {
-                    label: "About Vencord Desktop",
-                    click: createAboutWindow
-                },
-                {
-                    label: "Force Update Vencord",
-                    async click() {
-                        await downloadVencordFiles();
-                        app.relaunch();
-                        app.quit();
-                    },
-                    toolTip: "Vencord Desktop will automatically restart after this operation"
-                },
-                {
-                    label: "Toggle Developer Tools",
-                    accelerator: "CmdOrCtrl+Shift+I",
-                    click() {
-                        BrowserWindow.getFocusedWindow()!.webContents.toggleDevTools();
-                    }
-                },
-                {
-                    label: "Toggle Developer Tools (Hidden)",
-                    accelerator: "F12",
-                    visible: false,
-                    click() {
-                        BrowserWindow.getFocusedWindow()!.webContents.toggleDevTools();
-                    }
-                },
-                {
-                    label: "Reload Window",
-                    accelerator: "CmdOrCtrl+R",
-                    click() {
-                        BrowserWindow.getFocusedWindow()!.webContents.reload();
-                    }
-                },
-                {
-                    label: "Relaunch",
-                    accelerator: "CmdOrCtrl+Shift+R",
-                    click() {
-                        app.relaunch();
-                        app.quit();
-                    }
-                },
-                {
-                    label: "Quit",
-                    accelerator: process.platform === "win32" ? void 0 : "CmdOrCtrl+Q",
-                    // TODO: Setting
-                    visible: process.platform !== "win32",
-                    click() {
-                        app.quit();
-                    }
-                },
-                {
-                    label: "Quit",
-                    accelerator: "Alt+F4",
-                    visible: process.platform === "win32",
-                    acceleratorWorksWhenHidden: false,
-                    click() {
-                        app.quit();
-                    }
-                }
-            ]
+            label: "About Vesktop",
+            click: createAboutWindow
        },
        {
-            label: "Zoom",
-            submenu: [
-                {
-                    label: "Zoom in",
-                    accelerator: "CmdOrCtrl+Plus",
-                    role: "zoomIn"
-                },
-                // Fix for zoom in on keyboards with dedicated + like QWERTZ (or numpad)
-                // See https://github.com/electron/electron/issues/14742 and https://github.com/electron/electron/issues/5256
-                {
-                    label: "Zoom in",
-                    accelerator: "CmdOrCtrl+=",
-                    role: "zoomIn",
-                    visible: false
-                },
-                {
-                    label: "Zoom out",
-                    accelerator: "CmdOrCtrl+-",
-                    role: "zoomOut"
-                }
-            ]
+            label: "Force Update Vencord",
+            async click() {
+                await downloadVencordFiles();
+                app.relaunch();
+                app.quit();
+            },
+            toolTip: "Vesktop will automatically restart after this operation"
+        },
+        {
+            label: "Reset Vesktop",
+            async click() {
+                await clearData(win);
+            },
+            toolTip: "Vesktop will automatically restart after this operation"
+        },
+        {
+            label: "Relaunch",
+            accelerator: "CmdOrCtrl+Shift+R",
+            click() {
+                app.relaunch();
+                app.quit();
+            }
+        },
+        ...(!isDarwin
+            ? []
+            : ([
+                  {
+                      type: "separator"
+                  },
+                  {
+                      label: "Settings",
+                      accelerator: "CmdOrCtrl+,",
+                      async click() {
+                          mainWin.webContents.executeJavaScript(
+                              "Vencord.Webpack.Common.SettingsRouter.open('My Account')"
+                          );
+                      }
+                  },
+                  {
+                      type: "separator"
+                  },
+                  {
+                      label: "Hide Vesktop", // Should probably remove the label, but it says "Hide VencordDesktop" instead of "Hide Vesktop"
+                      role: "hide"
+                  },
+                  {
+                      role: "hideOthers"
+                  },
+                  {
+                      role: "unhide"
+                  },
+                  {
+                      type: "separator"
+                  }
+              ] satisfies MenuItemList)),
+        {
+            label: "Quit",
+            accelerator: wantCtrlQ ? "CmdOrCtrl+Q" : void 0,
+            visible: !isWindows,
+            role: "quit",
+            click() {
+                app.quit();
+            }
+        },
+        isWindows && {
+            label: "Quit",
+            accelerator: "Alt+F4",
+            role: "quit",
+            click() {
+                app.quit();
+            }
+        },
+        // See https://github.com/electron/electron/issues/14742 and https://github.com/electron/electron/issues/5256
+        {
+            label: "Zoom in (hidden, hack for Qwertz and others)",
+            accelerator: "CmdOrCtrl+=",
+            role: "zoomIn",
+            visible: false
        }
+    ] satisfies MenuItemList;
+
+    const menu = Menu.buildFromTemplate([
+        {
+            label: "Vesktop",
+            role: "appMenu",
+            submenu: subMenu.filter(isTruthy)
+        },
+        { role: "fileMenu" },
+        { role: "editMenu" },
+        { role: "viewMenu" },
+        { role: "windowMenu" }
    ]);

    Menu.setApplicationMenu(menu);
 }

-function getWindowBoundsOptions() {
-    const options = {} as BrowserWindowConstructorOptions;
+function getWindowBoundsOptions(): BrowserWindowConstructorOptions {
+    // We want the default window behaivour to apply in game mode since it expects everything to be fullscreen and maximized.
+    if (isDeckGameMode) return {};
+
+    const { x, y, width, height } = Settings.store.windowBounds ?? {};
+
+    const options = {
+        width: width ?? DEFAULT_WIDTH,
+        height: height ?? DEFAULT_HEIGHT
+    } as BrowserWindowConstructorOptions;

-    const { x, y, width, height } = Settings.windowBounds ?? {};
    if (x != null && y != null) {
        options.x = x;
        options.y = y;
    }

-    if (width) options.width = width;
-    if (height) options.height = height;
+    if (!Settings.store.disableMinSize) {
+        options.minWidth = MIN_WIDTH;
+        options.minHeight = MIN_HEIGHT;
+    }
+
+    return options;
+}
+
+function getDarwinOptions(): BrowserWindowConstructorOptions {
+    const options = {
+        titleBarStyle: "hidden",
+        trafficLightPosition: { x: 10, y: 10 }
+    } as BrowserWindowConstructorOptions;
+
+    const { splashTheming, splashBackground } = Settings.store;
+    const { macosTranslucency } = VencordSettings.store;
+
+    if (macosTranslucency) {
+        options.vibrancy = "sidebar";
+        options.backgroundColor = "#ffffff00";
+    } else {
+        if (splashTheming) {
+            options.backgroundColor = splashBackground;
+        } else {
+            options.backgroundColor = nativeTheme.shouldUseDarkColors ? "#313338" : "#ffffff";
+        }
+    }

    return options;
 }

 function initWindowBoundsListeners(win: BrowserWindow) {
-    win.on("maximize", () => {
-        Settings.maximized = true;
-        Settings.minimized = false;
-    });
+    const saveState = () => {
+        Settings.store.maximized = win.isMaximized();
+        Settings.store.minimized = win.isMinimized();
+    };

-    win.on("minimize", () => {
-        Settings.minimized = true;
-    });
-
-    win.on("unmaximize", () => {
-        Settings.maximized = false;
-        Settings.minimized = false;
-    });
+    win.on("maximize", saveState);
+    win.on("minimize", saveState);
+    win.on("unmaximize", saveState);

    const saveBounds = () => {
-        const [width, height] = win.getSize();
-        const [x, y] = win.getPosition();
-
-        Settings.windowBounds = {
-            width,
-            height,
-            x,
-            y
-        };
+        Settings.store.windowBounds = win.getBounds();
    };

    win.on("resize", saveBounds);
    win.on("move", saveBounds);
 }

-export function createMainWindow() {
-    const win = mainWin = new BrowserWindow({
+function initSettingsListeners(win: BrowserWindow) {
+    addSettingsListener("tray", enable => {
+        if (enable) initTray(win);
+        else tray?.destroy();
+    });
+    addSettingsListener("disableMinSize", disable => {
+        if (disable) {
+            // 0 no work
+            win.setMinimumSize(1, 1);
+        } else {
+            win.setMinimumSize(MIN_WIDTH, MIN_HEIGHT);
+
+            const { width, height } = win.getBounds();
+            win.setBounds({
+                width: Math.max(width, MIN_WIDTH),
+                height: Math.max(height, MIN_HEIGHT)
+            });
+        }
+    });
+
+    addVencordSettingsListener("macosTranslucency", enabled => {
+        if (enabled) {
+            win.setVibrancy("sidebar");
+            win.setBackgroundColor("#ffffff00");
+        } else {
+            win.setVibrancy(null);
+            win.setBackgroundColor("#ffffff");
+        }
+    });
+
+    addSettingsListener("enableMenu", enabled => {
+        win.setAutoHideMenuBar(enabled ?? false);
+    });
+}
+
+function initSpellCheck(win: BrowserWindow) {
+    win.webContents.on("context-menu", (_, data) => {
+        win.webContents.send(IpcEvents.SPELLCHECK_RESULT, data.misspelledWord, data.dictionarySuggestions);
+    });
+}
+
+function createMainWindow() {
+    // Clear up previous settings listeners
+    removeSettingsListeners();
+    removeVencordSettingsListeners();
+
+    const { staticTitle, transparencyOption, enableMenu, discordWindowsTitleBar } = Settings.store;
+
+    const { frameless } = VencordSettings.store;
+
+    const noFrame = frameless === true || (process.platform === "win32" && discordWindowsTitleBar === true);
+
+    const win = (mainWin = new BrowserWindow({
        show: false,
-        autoHideMenuBar: true,
        webPreferences: {
            nodeIntegration: false,
            sandbox: false,
            contextIsolation: true,
            devTools: true,
-            preload: join(__dirname, "preload.js")
+            preload: join(__dirname, "preload.js"),
+            spellcheck: true
        },
        icon: ICON_PATH,
-        ...getWindowBoundsOptions()
-    });
+        frame: !noFrame,
+        ...(transparencyOption &&
+            transparencyOption !== "none" && {
+                backgroundColor: "#00000000",
+                backgroundMaterial: transparencyOption,
+                transparent: true
+            }),
+        ...(staticTitle && { title: "Vesktop" }),
+        ...(process.platform === "darwin" && getDarwinOptions()),
+        ...getWindowBoundsOptions(),
+        autoHideMenuBar: enableMenu
+    }));
+    win.setMenuBarVisibility(false);

    win.on("close", e => {
-        if (isQuitting) return;
+        const useTray = !isDeckGameMode && Settings.store.minimizeToTray !== false && Settings.store.tray !== false;
+        if (isQuitting || (process.platform !== "darwin" && !useTray)) return;

        e.preventDefault();
-        win.hide();
+
+        if (process.platform === "darwin") app.hide();
+        else win.hide();

        return false;
    });

+    if (Settings.store.staticTitle) win.on("page-title-updated", e => e.preventDefault());
+
    initWindowBoundsListeners(win);
-    initTray(win);
+    if (!isDeckGameMode && (Settings.store.tray ?? true) && process.platform !== "darwin") initTray(win);
    initMenuBar(win);
    makeLinksOpenExternally(win);
+    initSettingsListeners(win);
+    initSpellCheck(win);

-    const subdomain = Settings.discordBranch === "canary" || Settings.discordBranch === "ptb"
-        ? `${Settings.discordBranch}.`
-        : "";
+    win.webContents.setUserAgent(UserAgent);
+
+    const subdomain =
+        Settings.store.discordBranch === "canary" || Settings.store.discordBranch === "ptb"
+            ? `${Settings.store.discordBranch}.`
+            : "";

    win.loadURL(`https://${subdomain}discord.com/app`);

    return win;
 }
+
+const runVencordMain = once(() => require(join(VENCORD_FILES_DIR, "vencordDesktopMain.js")));
+
+export async function createWindows() {
+    const splash = createSplashWindow();
+    // SteamOS letterboxes and scales it terribly, so just full screen it
+    if (isDeckGameMode) splash.setFullScreen(true);
+    await ensureVencordFiles();
+    runVencordMain();
+
+    mainWin = createMainWindow();
+
+    mainWin.webContents.on("did-finish-load", () => {
+        splash.destroy();
+        mainWin!.show();
+
+        if (Settings.store.maximized && !isDeckGameMode) {
+            mainWin!.maximize();
+        }
+
+        if (isDeckGameMode) {
+            // always use entire display
+            mainWin!.setFullScreen(true);
+
+            askToApplySteamLayout(mainWin);
+        }
+    });
+
+    initArRPC();
+}
--- a/src/main/mediaPermissions.ts
+++ b/src/main/mediaPermissions.ts
@@ -0,0 +1,24 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { session, systemPreferences } from "electron";
+
+export function registerMediaPermissionsHandler() {
+    if (process.platform !== "darwin") return;
+
+    session.defaultSession.setPermissionRequestHandler(async (_webContents, permission, callback, details) => {
+        let granted = true;
+
+        if (details.mediaTypes?.includes("audio")) {
+            granted = await systemPreferences.askForMediaAccess("microphone");
+        }
+        if (details.mediaTypes?.includes("video")) {
+            granted &&= await systemPreferences.askForMediaAccess("camera");
+        }
+
+        callback(granted);
+    });
+}
--- a/src/main/screenShare.ts
+++ b/src/main/screenShare.ts
@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { desktopCapturer, session, Streams } from "electron";
+import type { StreamPick } from "renderer/components/ScreenSharePicker";
+import { IpcEvents } from "shared/IpcEvents";
+
+import { handle } from "./utils/ipcWrappers";
+
+const isWayland =
+    process.platform === "linux" && (process.env.XDG_SESSION_TYPE === "wayland" || !!process.env.WAYLAND_DISPLAY);
+
+export function registerScreenShareHandler() {
+    handle(IpcEvents.CAPTURER_GET_LARGE_THUMBNAIL, async (_, id: string) => {
+        const sources = await desktopCapturer.getSources({
+            types: ["window", "screen"],
+            thumbnailSize: {
+                width: 1920,
+                height: 1080
+            }
+        });
+        return sources.find(s => s.id === id)?.thumbnail.toDataURL();
+    });
+
+    session.defaultSession.setDisplayMediaRequestHandler(async (request, callback) => {
+        // request full resolution on wayland right away because we always only end up with one result anyway
+        const width = isWayland ? 1920 : 176;
+        const sources = await desktopCapturer
+            .getSources({
+                types: ["window", "screen"],
+                thumbnailSize: {
+                    width,
+                    height: width * (9 / 16)
+                }
+            })
+            .catch(err => console.error("Error during screenshare picker", err));
+
+        if (!sources) return callback({});
+
+        const data = sources.map(({ id, name, thumbnail }) => ({
+            id,
+            name,
+            url: thumbnail.toDataURL()
+        }));
+
+        if (isWayland) {
+            const video = data[0];
+            if (video) {
+                const stream = await request.frame
+                    .executeJavaScript(
+                        `Vesktop.Components.ScreenShare.openScreenSharePicker(${JSON.stringify([video])},true)`
+                    )
+                    .catch(() => null);
+                if (stream === null) return callback({});
+            }
+
+            callback(video ? { video: sources[0] } : {});
+            return;
+        }
+
+        const choice = await request.frame
+            .executeJavaScript(`Vesktop.Components.ScreenShare.openScreenSharePicker(${JSON.stringify(data)})`)
+            .then(e => e as StreamPick)
+            .catch(e => {
+                console.error("Error during screenshare picker", e);
+                return null;
+            });
+
+        if (!choice) return callback({});
+
+        const source = sources.find(s => s.id === choice.id);
+        if (!source) return callback({});
+
+        const streams: Streams = {
+            video: source
+        };
+        if (choice.audio && process.platform === "win32") streams.audio = "loopback";
+
+        callback(streams);
+    });
+}
--- a/src/main/settings.ts
+++ b/src/main/settings.ts
@@ -1,49 +1,37 @@
-import { readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { DATA_DIR } from "./constants";
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import type { Settings as TSettings } from "shared/settings";
+import { SettingsStore } from "shared/utils/SettingsStore";
+
+import { DATA_DIR, VENCORD_SETTINGS_FILE } from "./constants";

 const SETTINGS_FILE = join(DATA_DIR, "settings.json");

-interface Settings {
-    maximized?: boolean;
-    minimized?: boolean;
-    windowBounds?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    discordBranch?: "stable" | "canary" | "ptb";
-    openLinksWithElectron?: boolean;
-}
-
-export let PlainSettings = {} as Settings;
-try {
-    const content = readFileSync(SETTINGS_FILE, "utf8");
+function loadSettings<T extends object = any>(file: string, name: string) {
+    let settings = {} as T;
    try {
-        PlainSettings = JSON.parse(content);
-    } catch (err) {
-        console.error("Failed to parse settings.json:", err);
-    }
-} catch { }
-
-function makeSettingsProxy(settings: Settings) {
-    return new Proxy(settings, {
-        set(target, prop, value) {
-            Reflect.set(target, prop, value);
-
-            writeFileSync(SETTINGS_FILE, JSON.stringify(target, null, 4));
-
-            return true;
+        const content = readFileSync(file, "utf8");
+        try {
+            settings = JSON.parse(content);
+        } catch (err) {
+            console.error(`Failed to parse ${name} settings.json:`, err);
        }
+    } catch {}
+
+    const store = new SettingsStore(settings);
+    store.addGlobalChangeListener(o => {
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, JSON.stringify(o, null, 4));
    });
+
+    return store;
 }

-export let Settings = makeSettingsProxy(PlainSettings);
-
-export function setSettings(settings: Settings) {
-    writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 4));
-    PlainSettings = settings;
-    Settings = makeSettingsProxy(settings);
-}
-
+export const Settings = loadSettings<TSettings>(SETTINGS_FILE, "Vesktop");
+export const VencordSettings = loadSettings<any>(VENCORD_SETTINGS_FILE, "Vencord");
--- a/src/main/splash.ts
+++ b/src/main/splash.ts
@@ -1,19 +1,38 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import { BrowserWindow } from "electron";
 import { join } from "path";
-import { STATIC_DIR } from "shared/paths";
+import { SplashProps } from "shared/browserWinProperties";
+import { ICON_PATH, VIEW_DIR } from "shared/paths";
+
+import { Settings } from "./settings";

 export function createSplashWindow() {
    const splash = new BrowserWindow({
-        transparent: true,
-        frame: false,
-        height: 350,
-        width: 300,
-        center: true,
-        resizable: false,
-        maximizable: false
+        ...SplashProps,
+        icon: ICON_PATH
    });

-    splash.loadFile(join(STATIC_DIR, "splash.html"));
+    splash.loadFile(join(VIEW_DIR, "splash.html"));
+
+    const { splashBackground, splashColor, splashTheming } = Settings.store;
+
+    if (splashTheming) {
+        if (splashColor) {
+            const semiTransparentSplashColor = splashColor.replace("rgb(", "rgba(").replace(")", ", 0.2)");
+
+            splash.webContents.insertCSS(`body { --fg: ${splashColor} !important }`);
+            splash.webContents.insertCSS(`body { --fg-semi-trans: ${semiTransparentSplashColor} !important }`);
+        }
+
+        if (splashBackground) {
+            splash.webContents.insertCSS(`body { --bg: ${splashBackground} !important }`);
+        }
+    }

    return splash;
 }
--- a/src/main/utils/http.ts
+++ b/src/main/utils/http.ts
@@ -1,14 +1,22 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import { createWriteStream } from "fs";
 import type { IncomingMessage } from "http";
-import { RequestOptions, get } from "https";
+import { get, RequestOptions } from "https";
 import { finished } from "stream/promises";

 export async function downloadFile(url: string, file: string, options: RequestOptions = {}) {
    const res = await simpleReq(url, options);
    await finished(
-        res.pipe(createWriteStream(file, {
-            autoClose: true
-        }))
+        res.pipe(
+            createWriteStream(file, {
+                autoClose: true
+            })
+        )
    );
 }

@@ -16,12 +24,8 @@ export function simpleReq(url: string, options: RequestOptions = {}) {
    return new Promise<IncomingMessage>((resolve, reject) => {
        get(url, options, res => {
            const { statusCode, statusMessage, headers } = res;
-            if (statusCode! >= 400)
-                return void reject(`${statusCode}: ${statusMessage} - ${url}`);
-            if (statusCode! >= 300)
-                return simpleReq(headers.location!, options)
-                    .then(resolve)
-                    .catch(reject);
+            if (statusCode! >= 400) return void reject(`${statusCode}: ${statusMessage} - ${url}`);
+            if (statusCode! >= 300) return simpleReq(headers.location!, options).then(resolve).catch(reject);

            resolve(res);
        });
--- a/src/main/utils/ipcWrappers.ts
+++ b/src/main/utils/ipcWrappers.ts
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { ipcMain, IpcMainEvent, IpcMainInvokeEvent, WebFrameMain } from "electron";
+import { IpcEvents } from "shared/IpcEvents";
+
+export function validateSender(frame: WebFrameMain) {
+    const { hostname, protocol } = new URL(frame.url);
+    if (protocol === "file:") return;
+
+    switch (hostname) {
+        case "discord.com":
+        case "ptb.discord.com":
+        case "canary.discord.com":
+            break;
+        default:
+            throw new Error("ipc: Disallowed host " + hostname);
+    }
+}
+
+export function handleSync(event: IpcEvents, cb: (e: IpcMainEvent, ...args: any[]) => any) {
+    ipcMain.on(event, (e, ...args) => {
+        validateSender(e.senderFrame);
+        e.returnValue = cb(e, ...args);
+    });
+}
+
+export function handle(event: IpcEvents, cb: (e: IpcMainInvokeEvent, ...args: any[]) => any) {
+    ipcMain.handle(event, (e, ...args) => {
+        validateSender(e.senderFrame);
+        return cb(e, ...args);
+    });
+}
--- a/src/main/utils/makeLinksOpenExternally.ts
+++ b/src/main/utils/makeLinksOpenExternally.ts
@@ -1,4 +1,11 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import { BrowserWindow, shell } from "electron";
+
 import { Settings } from "../settings";

 export function makeLinksOpenExternally(win: BrowserWindow) {
@@ -10,7 +17,7 @@ export function makeLinksOpenExternally(win: BrowserWindow) {
        }

        try {
-            var protocol = new URL(url).protocol;
+            var { protocol } = new URL(url);
        } catch {
            return { action: "deny" };
        }
@@ -18,9 +25,10 @@ export function makeLinksOpenExternally(win: BrowserWindow) {
        switch (protocol) {
            case "http:":
            case "https:":
-                if (Settings.openLinksWithElectron) {
+                if (Settings.store.openLinksWithElectron) {
                    return { action: "allow" };
                }
+            // eslint-disable-next-line no-fallthrough
            case "mailto:":
            case "steam:":
            case "spotify:":
--- a/src/main/utils/steamOS.ts
+++ b/src/main/utils/steamOS.ts
@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { exec as callbackExec } from "child_process";
+import { BrowserWindow, dialog } from "electron";
+import { sleep } from "shared/utils/sleep";
+import { promisify } from "util";
+
+import { MessageBoxChoice } from "../constants";
+import { Settings } from "../settings";
+
+const exec = promisify(callbackExec);
+
+// Bump this to re-show the prompt
+const layoutVersion = 1;
+// Get this from "show details" on the profile after exporting as a shared personal layout or using share with community
+const layoutId = "3063409873"; // Vesktop Layout v1
+const numberRegex = /^[0-9]*$/;
+
+export const isDeckGameMode = process.env.SteamOS === "1" && process.env.SteamGamepadUI === "1";
+
+export function applyDeckKeyboardFix() {
+    if (!isDeckGameMode) return;
+    // Prevent constant virtual keyboard spam that eventually crashes Steam.
+    process.env.GTK_IM_MODULE = "None";
+}
+
+// For some reason SteamAppId is always 0 for non-steam apps so we do this insanity instead.
+function getAppId(): string | null {
+    // /home/deck/.local/share/Steam/steamapps/shadercache/APPID/fozmediav1
+    const path = process.env.STEAM_COMPAT_MEDIA_PATH;
+    if (!path) return null;
+    const pathElems = path?.split("/");
+    const appId = pathElems[pathElems.length - 2];
+    if (appId.match(numberRegex)) {
+        console.log(`Got Steam App ID ${appId}`);
+        return appId;
+    }
+    return null;
+}
+
+async function execSteamURL(url: string): Promise<void> {
+    await exec(`steam -ifrunning ${url}`);
+}
+
+async function showLayout(appId: string) {
+    await execSteamURL(`steam://controllerconfig/${appId}/${layoutId}`);
+    // because the UI doesn't consistently reload after the data for the config has loaded...
+    // HOW HAS NOBODY AT VALVE RUN INTO THIS YET
+    await sleep(100);
+    await execSteamURL(`steam://controllerconfig/${appId}/${layoutId}`);
+}
+
+export async function askToApplySteamLayout(win: BrowserWindow) {
+    const appId = getAppId();
+    if (!appId) return;
+    if (Settings.store.steamOSLayoutVersion === layoutVersion) return;
+    const update = Boolean(Settings.store.steamOSLayoutVersion);
+
+    // Touch screen breaks in some menus when native touch mode is enabled on latest SteamOS beta, remove most of the update specific text once that's fixed.
+    const { response } = await dialog.showMessageBox(win, {
+        message: `${update ? "Update" : "Apply"} Vesktop Steam Input Layout?`,
+        detail: `Would you like to ${update ? "Update" : "Apply"} Vesktop's recommended Steam Deck controller settings?
+${update ? "Click yes using the touchpad" : "Tap yes"}, then press the X button or tap Apply Layout to confirm.${
+            update ? " Doing so will undo any customizations you have made." : ""
+        }
+${update ? "Click" : "Tap"} no to keep your current layout.`,
+        buttons: ["Yes", "No"],
+        cancelId: MessageBoxChoice.Cancel,
+        defaultId: MessageBoxChoice.Default,
+        type: "question"
+    });
+
+    if (Settings.store.steamOSLayoutVersion !== layoutVersion) {
+        Settings.store.steamOSLayoutVersion = layoutVersion;
+    }
+
+    if (response === MessageBoxChoice.Cancel) return;
+
+    await showLayout(appId);
+}
--- a/src/main/utils/vencordLoader.ts
+++ b/src/main/utils/vencordLoader.ts
@@ -1,53 +1,66 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import { existsSync, mkdirSync } from "fs";
+import type { RequestOptions } from "https";
 import { join } from "path";
+
 import { USER_AGENT, VENCORD_FILES_DIR } from "../constants";
 import { downloadFile, simpleGet } from "./http";

-// TODO: Setting to switch repo
-const API_BASE = "https://api.github.com/repos/Vendicated/Vencord";
+const API_BASE = "https://api.github.com";

-const FILES_TO_DOWNLOAD = [
+export const FILES_TO_DOWNLOAD = [
    "vencordDesktopMain.js",
-    "preload.js",
+    "vencordDesktopPreload.js",
    "vencordDesktopRenderer.js",
-    "renderer.css"
+    "vencordDesktopRenderer.css"
 ];

+export interface ReleaseData {
+    name: string;
+    tag_name: string;
+    html_url: string;
+    assets: Array<{
+        name: string;
+        browser_download_url: string;
+    }>;
+}
+
 export async function githubGet(endpoint: string) {
-    return simpleGet(API_BASE + endpoint, {
+    const opts: RequestOptions = {
        headers: {
            Accept: "application/vnd.github+json",
            "User-Agent": USER_AGENT
        }
-    });
+    };
+
+    if (process.env.GITHUB_TOKEN) opts.headers!.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+
+    return simpleGet(API_BASE + endpoint, opts);
 }

 export async function downloadVencordFiles() {
-    const release = await githubGet("/releases/latest");
+    const release = await githubGet("/repos/Vendicated/Vencord/releases/latest");

-    const data = JSON.parse(release.toString("utf-8"));
-    const assets = data.assets as Array<{
-        name: string;
-        browser_download_url: string;
-    }>;
+    const { assets } = JSON.parse(release.toString("utf-8")) as ReleaseData;

    await Promise.all(
        assets
            .filter(({ name }) => FILES_TO_DOWNLOAD.some(f => name.startsWith(f)))
-            .map(({ name, browser_download_url }) =>
-                downloadFile(
-                    browser_download_url,
-                    join(
-                        VENCORD_FILES_DIR,
-                        name.replace(/vencordDesktop(\w)/, (_, c) => c.toLowerCase())
-                    )
-                )
-            )
+            .map(({ name, browser_download_url }) => downloadFile(browser_download_url, join(VENCORD_FILES_DIR, name)))
    );
 }

+export function isValidVencordInstall(dir: string) {
+    return FILES_TO_DOWNLOAD.every(f => existsSync(join(dir, f)));
+}
+
 export async function ensureVencordFiles() {
-    if (existsSync(join(VENCORD_FILES_DIR, "main.js"))) return;
+    if (isValidVencordInstall(VENCORD_FILES_DIR)) return;
    mkdirSync(VENCORD_FILES_DIR, { recursive: true });

    await downloadVencordFiles();
--- a/src/main/virtmic.ts
+++ b/src/main/virtmic.ts
@@ -0,0 +1,74 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { app, ipcMain } from "electron";
+import { join } from "path";
+import { IpcEvents } from "shared/IpcEvents";
+import { STATIC_DIR } from "shared/paths";
+
+let initialized = false;
+let patchBay: import("@vencord/venmic").PatchBay | undefined;
+let isGlibcxxToOld = false;
+
+function getRendererAudioServicePid() {
+    return (
+        app
+            .getAppMetrics()
+            .find(proc => proc.name === "Audio Service")
+            ?.pid?.toString() ?? "owo"
+    );
+}
+
+function obtainVenmic() {
+    if (!initialized) {
+        initialized = true;
+        try {
+            const { PatchBay } = require(
+                join(STATIC_DIR, `dist/venmic-${process.arch}.node`)
+            ) as typeof import("@vencord/venmic");
+            patchBay = new PatchBay();
+        } catch (e: any) {
+            console.error("Failed to initialise venmic. Make sure you're using pipewire", e);
+            isGlibcxxToOld = (e?.stack || e?.message || "").toLowerCase().includes("glibc");
+        }
+    }
+
+    return patchBay;
+}
+
+ipcMain.handle(IpcEvents.VIRT_MIC_LIST, () => {
+    const audioPid = getRendererAudioServicePid();
+    const list = obtainVenmic()
+        ?.list()
+        .filter(s => s["application.process.id"] !== audioPid)
+        .map(s => s["application.name"]);
+
+    return list
+        ? { ok: true, targets: [...new Set(list)] } // Remove duplicates
+        : { ok: false, isGlibcxxToOld };
+});
+
+ipcMain.handle(
+    IpcEvents.VIRT_MIC_START,
+    (_, target: string) =>
+        obtainVenmic()?.link({
+            key: "application.name",
+            value: target,
+            mode: "include"
+        })
+);
+
+ipcMain.handle(
+    IpcEvents.VIRT_MIC_START_SYSTEM,
+    () =>
+        obtainVenmic()?.link({
+            key: "application.process.id",
+            value: getRendererAudioServicePid(),
+            mode: "exclude"
+        })
+);
+
+ipcMain.handle(IpcEvents.VIRT_MIC_STOP, () => obtainVenmic()?.unlink());
--- a/src/preload/VencordDesktop.ts
+++ b/src/preload/VencordDesktop.ts
@@ -1,20 +0,0 @@
-import { ipcRenderer } from "electron";
-import type { Settings } from "../main/settings";
-import { FOCUS, GET_SETTINGS, RELAUNCH, SET_SETTINGS, SHOW_ITEM_IN_FOLDER } from "../shared/IpcEvents";
-
-export const VencordDesktop = {
-    app: {
-        relaunch: () => ipcRenderer.invoke(RELAUNCH)
-    },
-    fileManager: {
-        showItemInFolder: (path: string) => ipcRenderer.invoke(SHOW_ITEM_IN_FOLDER, path)
-    },
-    settings: {
-        get: () => ipcRenderer.sendSync(GET_SETTINGS),
-        set: (settings: typeof Settings) => ipcRenderer.invoke(SET_SETTINGS, settings)
-    },
-    win: {
-        focus: () => ipcRenderer.invoke(FOCUS)
-    }
-}
-
--- a/src/preload/VesktopNative.ts
+++ b/src/preload/VesktopNative.ts
@@ -0,0 +1,75 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { ipcRenderer } from "electron";
+import type { Settings } from "shared/settings";
+import type { LiteralUnion } from "type-fest";
+
+import { IpcEvents } from "../shared/IpcEvents";
+import { invoke, sendSync } from "./typedIpc";
+
+type SpellCheckerResultCallback = (word: string, suggestions: string[]) => void;
+
+const spellCheckCallbacks = new Set<SpellCheckerResultCallback>();
+
+ipcRenderer.on(IpcEvents.SPELLCHECK_RESULT, (_, w: string, s: string[]) => {
+    spellCheckCallbacks.forEach(cb => cb(w, s));
+});
+
+export const VesktopNative = {
+    app: {
+        relaunch: () => invoke<void>(IpcEvents.RELAUNCH),
+        getVersion: () => sendSync<void>(IpcEvents.GET_VERSION),
+        setBadgeCount: (count: number) => invoke<void>(IpcEvents.SET_BADGE_COUNT, count),
+        supportsWindowsTransparency: () => sendSync<boolean>(IpcEvents.SUPPORTS_WINDOWS_TRANSPARENCY)
+    },
+    autostart: {
+        isEnabled: () => sendSync<boolean>(IpcEvents.AUTOSTART_ENABLED),
+        enable: () => invoke<void>(IpcEvents.ENABLE_AUTOSTART),
+        disable: () => invoke<void>(IpcEvents.DISABLE_AUTOSTART)
+    },
+    fileManager: {
+        showItemInFolder: (path: string) => invoke<void>(IpcEvents.SHOW_ITEM_IN_FOLDER, path),
+        selectVencordDir: () => invoke<LiteralUnion<"cancelled" | "invalid", string>>(IpcEvents.SELECT_VENCORD_DIR)
+    },
+    settings: {
+        get: () => sendSync<Settings>(IpcEvents.GET_SETTINGS),
+        set: (settings: Settings, path?: string) => invoke<void>(IpcEvents.SET_SETTINGS, settings, path)
+    },
+    spellcheck: {
+        setLanguages: (languages: readonly string[]) => invoke<void>(IpcEvents.SPELLCHECK_SET_LANGUAGES, languages),
+        onSpellcheckResult(cb: SpellCheckerResultCallback) {
+            spellCheckCallbacks.add(cb);
+        },
+        offSpellcheckResult(cb: SpellCheckerResultCallback) {
+            spellCheckCallbacks.delete(cb);
+        },
+        replaceMisspelling: (word: string) => invoke<void>(IpcEvents.SPELLCHECK_REPLACE_MISSPELLING, word),
+        addToDictionary: (word: string) => invoke<void>(IpcEvents.SPELLCHECK_ADD_TO_DICTIONARY, word)
+    },
+    win: {
+        focus: () => invoke<void>(IpcEvents.FOCUS),
+        close: () => invoke<void>(IpcEvents.CLOSE),
+        minimize: () => invoke<void>(IpcEvents.MINIMIZE),
+        maximize: () => invoke<void>(IpcEvents.MAXIMIZE)
+    },
+    capturer: {
+        getLargeThumbnail: (id: string) => invoke<string>(IpcEvents.CAPTURER_GET_LARGE_THUMBNAIL, id)
+    },
+    /** only available on Linux. */
+    virtmic: {
+        list: () =>
+            invoke<{ ok: false; isGlibcxxToOld: boolean } | { ok: true; targets: string[] }>(IpcEvents.VIRT_MIC_LIST),
+        start: (target: string) => invoke<void>(IpcEvents.VIRT_MIC_START, target),
+        startSystem: () => invoke<void>(IpcEvents.VIRT_MIC_START_SYSTEM),
+        stop: () => invoke<void>(IpcEvents.VIRT_MIC_STOP)
+    },
+    arrpc: {
+        onActivity(cb: (data: string) => void) {
+            ipcRenderer.on(IpcEvents.ARRPC_ACTIVITY, (_, data: string) => cb(data));
+        }
+    }
+};
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -1,10 +1,44 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import { contextBridge, ipcRenderer, webFrame } from "electron";
-import { GET_RENDERER_SCRIPT, GET_RENDERER_STYLES, GET_VENCORD_PRELOAD_FILE } from "../shared/IpcEvents";
-import { VencordDesktop } from "./VencordDesktop";
+import { readFileSync, watch } from "fs";

-contextBridge.exposeInMainWorld("VencordDesktop", VencordDesktop);
+import { IpcEvents } from "../shared/IpcEvents";
+import { VesktopNative } from "./VesktopNative";

-require(ipcRenderer.sendSync(GET_VENCORD_PRELOAD_FILE));
+contextBridge.exposeInMainWorld("VesktopNative", VesktopNative);

-webFrame.executeJavaScript(ipcRenderer.sendSync(GET_RENDERER_SCRIPT));
-ipcRenderer.invoke(GET_RENDERER_STYLES).then(s => webFrame.insertCSS(s));
+require(ipcRenderer.sendSync(IpcEvents.GET_VENCORD_PRELOAD_FILE));
+
+webFrame.executeJavaScript(ipcRenderer.sendSync(IpcEvents.GET_VENCORD_RENDERER_SCRIPT));
+webFrame.executeJavaScript(ipcRenderer.sendSync(IpcEvents.GET_RENDERER_SCRIPT));
+
+// #region css
+const rendererCss = ipcRenderer.sendSync(IpcEvents.GET_RENDERER_CSS_FILE);
+
+const style = document.createElement("style");
+style.id = "vcd-css-core";
+style.textContent = readFileSync(rendererCss, "utf-8");
+
+if (document.readyState === "complete") {
+    document.documentElement.appendChild(style);
+} else {
+    document.addEventListener("DOMContentLoaded", () => document.documentElement.appendChild(style), {
+        once: true
+    });
+}
+
+if (IS_DEV) {
+    // persistent means keep process running if watcher is the only thing still running
+    // which we obviously don't want
+    watch(rendererCss, { persistent: false }, () => {
+        document.getElementById("vcd-css-core")!.textContent = readFileSync(rendererCss, "utf-8");
+    });
+}
+// #endregion
+
+VesktopNative.spellcheck.setLanguages(window.navigator.languages);
--- a/src/preload/typedIpc.ts
+++ b/src/preload/typedIpc.ts
@@ -0,0 +1,16 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { ipcRenderer } from "electron";
+import { IpcEvents } from "shared/IpcEvents";
+
+export function invoke<T = any>(event: IpcEvents, ...args: any[]) {
+    return ipcRenderer.invoke(event, ...args) as Promise<T>;
+}
+
+export function sendSync<T = any>(event: IpcEvents, ...args: any[]) {
+    return ipcRenderer.sendSync(event, ...args) as T;
+}
--- a/src/renderer/appBadge.ts
+++ b/src/renderer/appBadge.ts
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { filters, waitFor } from "@vencord/types/webpack";
+import { RelationshipStore } from "@vencord/types/webpack/common";
+
+import { Settings } from "./settings";
+
+let GuildReadStateStore: any;
+let NotificationSettingsStore: any;
+
+export function setBadge() {
+    if (Settings.store.appBadge === false) return;
+
+    try {
+        const mentionCount = GuildReadStateStore.getTotalMentionCount();
+        const pendingRequests = RelationshipStore.getPendingCount();
+        const hasUnread = GuildReadStateStore.hasAnyUnread();
+        const disableUnreadBadge = NotificationSettingsStore.getDisableUnreadBadge();
+
+        let totalCount = mentionCount + pendingRequests;
+        if (!totalCount && hasUnread && !disableUnreadBadge) totalCount = -1;
+
+        VesktopNative.app.setBadgeCount(totalCount);
+    } catch (e) {
+        console.error(e);
+    }
+}
+
+let toFind = 3;
+
+function waitForAndSubscribeToStore(name: string, cb?: (m: any) => void) {
+    waitFor(filters.byStoreName(name), store => {
+        cb?.(store);
+        store.addChangeListener(setBadge);
+
+        toFind--;
+        if (toFind === 0) setBadge();
+    });
+}
+
+waitForAndSubscribeToStore("GuildReadStateStore", store => (GuildReadStateStore = store));
+waitForAndSubscribeToStore("NotificationSettingsStore", store => (NotificationSettingsStore = store));
+waitForAndSubscribeToStore("RelationshipStore");
--- a/src/renderer/components/ScreenSharePicker.tsx
+++ b/src/renderer/components/ScreenSharePicker.tsx
@@ -0,0 +1,367 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import "./screenSharePicker.css";
+
+import { closeModal, Modals, openModal, useAwaiter } from "@vencord/types/utils";
+import { findStoreLazy, onceReady } from "@vencord/types/webpack";
+import {
+    Button,
+    Card,
+    FluxDispatcher,
+    Forms,
+    Select,
+    Switch,
+    Text,
+    UserStore,
+    useState
+} from "@vencord/types/webpack/common";
+import type { Dispatch, SetStateAction } from "react";
+import { addPatch } from "renderer/patches/shared";
+import { isLinux, isWindows } from "renderer/utils";
+
+const StreamResolutions = ["480", "720", "1080", "1440"] as const;
+const StreamFps = ["15", "30", "60"] as const;
+
+const MediaEngineStore = findStoreLazy("MediaEngineStore");
+
+export type StreamResolution = (typeof StreamResolutions)[number];
+export type StreamFps = (typeof StreamFps)[number];
+
+interface StreamSettings {
+    resolution: StreamResolution;
+    fps: StreamFps;
+    audio: boolean;
+    audioSource?: string;
+}
+
+export interface StreamPick extends StreamSettings {
+    id: string;
+}
+
+interface Source {
+    id: string;
+    name: string;
+    url: string;
+}
+
+let currentSettings: StreamSettings | null = null;
+
+addPatch({
+    patches: [
+        {
+            find: "this.localWant=",
+            replacement: {
+                match: /this.localWant=/,
+                replace: "$self.patchStreamQuality(this);$&"
+            }
+        }
+    ],
+    patchStreamQuality(opts: any) {
+        if (!currentSettings) return;
+
+        const framerate = Number(currentSettings.fps);
+        const height = Number(currentSettings.resolution);
+        const width = Math.round(height * (16 / 9));
+
+        Object.assign(opts, {
+            bitrateMin: 500000,
+            bitrateMax: 8000000,
+            bitrateTarget: 600000
+        });
+        Object.assign(opts.capture, {
+            framerate,
+            width,
+            height,
+            pixelCount: height * width
+        });
+    }
+});
+
+if (isLinux) {
+    onceReady.then(() => {
+        FluxDispatcher.subscribe("VOICE_STATE_UPDATES", e => {
+            for (const state of e.voiceStates) {
+                if (state.userId === UserStore.getCurrentUser().id && state.oldChannelId && !state.channelId)
+                    VesktopNative.virtmic.stop();
+            }
+        });
+    });
+}
+
+export function openScreenSharePicker(screens: Source[], skipPicker: boolean) {
+    let didSubmit = false;
+    return new Promise<StreamPick>((resolve, reject) => {
+        const key = openModal(
+            props => (
+                <ModalComponent
+                    screens={screens}
+                    modalProps={props}
+                    submit={async v => {
+                        didSubmit = true;
+                        if (v.audioSource && v.audioSource !== "None") {
+                            if (v.audioSource === "Entire System") {
+                                await VesktopNative.virtmic.startSystem();
+                            } else {
+                                await VesktopNative.virtmic.start(v.audioSource);
+                            }
+                        }
+                        resolve(v);
+                    }}
+                    close={() => {
+                        props.onClose();
+                        if (!didSubmit) reject("Aborted");
+                    }}
+                    skipPicker={skipPicker}
+                />
+            ),
+            {
+                onCloseRequest() {
+                    closeModal(key);
+                    reject("Aborted");
+                }
+            }
+        );
+    });
+}
+
+function ScreenPicker({ screens, chooseScreen }: { screens: Source[]; chooseScreen: (id: string) => void }) {
+    return (
+        <div className="vcd-screen-picker-grid">
+            {screens.map(({ id, name, url }) => (
+                <label key={id}>
+                    <input type="radio" name="screen" value={id} onChange={() => chooseScreen(id)} />
+
+                    <img src={url} alt="" />
+                    <Text variant="text-sm/normal">{name}</Text>
+                </label>
+            ))}
+        </div>
+    );
+}
+
+function StreamSettings({
+    source,
+    settings,
+    setSettings,
+    skipPicker
+}: {
+    source: Source;
+    settings: StreamSettings;
+    setSettings: Dispatch<SetStateAction<StreamSettings>>;
+    skipPicker: boolean;
+}) {
+    const [thumb] = useAwaiter(
+        () => (skipPicker ? Promise.resolve(source.url) : VesktopNative.capturer.getLargeThumbnail(source.id)),
+        {
+            fallbackValue: source.url,
+            deps: [source.id]
+        }
+    );
+
+    return (
+        <div>
+            <Forms.FormTitle>What you're streaming</Forms.FormTitle>
+            <Card className="vcd-screen-picker-card vcd-screen-picker-preview">
+                <img src={thumb} alt="" />
+                <Text variant="text-sm/normal">{source.name}</Text>
+            </Card>
+
+            <Forms.FormTitle>Stream Settings</Forms.FormTitle>
+
+            <Card className="vcd-screen-picker-card">
+                <div className="vcd-screen-picker-quality">
+                    <section>
+                        <Forms.FormTitle>Resolution</Forms.FormTitle>
+                        <div className="vcd-screen-picker-radios">
+                            {StreamResolutions.map(res => (
+                                <label className="vcd-screen-picker-radio" data-checked={settings.resolution === res}>
+                                    <Text variant="text-sm/bold">{res}</Text>
+                                    <input
+                                        type="radio"
+                                        name="resolution"
+                                        value={res}
+                                        checked={settings.resolution === res}
+                                        onChange={() => setSettings(s => ({ ...s, resolution: res }))}
+                                    />
+                                </label>
+                            ))}
+                        </div>
+                    </section>
+
+                    <section>
+                        <Forms.FormTitle>Frame Rate</Forms.FormTitle>
+                        <div className="vcd-screen-picker-radios">
+                            {StreamFps.map(fps => (
+                                <label className="vcd-screen-picker-radio" data-checked={settings.fps === fps}>
+                                    <Text variant="text-sm/bold">{fps}</Text>
+                                    <input
+                                        type="radio"
+                                        name="fps"
+                                        value={fps}
+                                        checked={settings.fps === fps}
+                                        onChange={() => setSettings(s => ({ ...s, fps }))}
+                                    />
+                                </label>
+                            ))}
+                        </div>
+                    </section>
+                </div>
+
+                {isWindows && (
+                    <Switch
+                        value={settings.audio}
+                        onChange={checked => setSettings(s => ({ ...s, audio: checked }))}
+                        hideBorder
+                        className="vcd-screen-picker-audio"
+                    >
+                        Stream With Audio
+                    </Switch>
+                )}
+
+                {isLinux && (
+                    <AudioSourcePickerLinux
+                        audioSource={settings.audioSource}
+                        setAudioSource={source => setSettings(s => ({ ...s, audioSource: source }))}
+                    />
+                )}
+            </Card>
+        </div>
+    );
+}
+
+function AudioSourcePickerLinux({
+    audioSource,
+    setAudioSource
+}: {
+    audioSource?: string;
+    setAudioSource(s: string): void;
+}) {
+    const [sources, _, loading] = useAwaiter(() => VesktopNative.virtmic.list(), {
+        fallbackValue: { ok: true, targets: [] }
+    });
+    const allSources = sources.ok ? ["None", "Entire System", ...sources.targets] : null;
+
+    return (
+        <section>
+            <Forms.FormTitle>Audio</Forms.FormTitle>
+            {loading && <Forms.FormTitle>Loading Audio sources...</Forms.FormTitle>}
+            {!sources.ok &&
+                (sources.isGlibcxxToOld ? (
+                    <Forms.FormText>
+                        Failed to retrieve Audio Sources because your c++ library is too old to run venmic. If you would
+                        like to stream with Audio, see{" "}
+                        <a href="https://gist.github.com/Vendicated/b655044ffbb16b2716095a448c6d827a" target="_blank">
+                            this guide
+                        </a>
+                    </Forms.FormText>
+                ) : (
+                    <Forms.FormText>
+                        Failed to retrieve Audio Sources. If you would like to stream with Audio, make sure you're using
+                        Pipewire, not Pulseaudio
+                    </Forms.FormText>
+                ))}
+
+            {allSources && (
+                <Select
+                    options={allSources.map(s => ({ label: s, value: s, default: s === "None" }))}
+                    isSelected={s => s === audioSource}
+                    select={setAudioSource}
+                    serialize={String}
+                />
+            )}
+        </section>
+    );
+}
+
+function ModalComponent({
+    screens,
+    modalProps,
+    submit,
+    close,
+    skipPicker
+}: {
+    screens: Source[];
+    modalProps: any;
+    submit: (data: StreamPick) => void;
+    close: () => void;
+    skipPicker: boolean;
+}) {
+    const [selected, setSelected] = useState<string | undefined>(skipPicker ? screens[0].id : void 0);
+    const [settings, setSettings] = useState<StreamSettings>({
+        resolution: "1080",
+        fps: "60",
+        audio: true
+    });
+
+    return (
+        <Modals.ModalRoot {...modalProps}>
+            <Modals.ModalHeader className="vcd-screen-picker-header">
+                <Forms.FormTitle tag="h2">ScreenShare</Forms.FormTitle>
+                <Modals.ModalCloseButton onClick={close} />
+            </Modals.ModalHeader>
+
+            <Modals.ModalContent className="vcd-screen-picker-modal">
+                {!selected ? (
+                    <ScreenPicker screens={screens} chooseScreen={setSelected} />
+                ) : (
+                    <StreamSettings
+                        source={screens.find(s => s.id === selected)!}
+                        settings={settings}
+                        setSettings={setSettings}
+                        skipPicker={skipPicker}
+                    />
+                )}
+            </Modals.ModalContent>
+
+            <Modals.ModalFooter className="vcd-screen-picker-footer">
+                <Button
+                    disabled={!selected}
+                    onClick={() => {
+                        currentSettings = settings;
+
+                        // If there are 2 connections, the second one is the existing stream.
+                        // In that case, we patch its quality
+                        const conn = [...MediaEngineStore.getMediaEngine().connections][1];
+                        if (conn && conn.videoStreamParameters.length > 0) {
+                            const height = Number(settings.resolution);
+                            const width = Math.round(height * (16 / 9));
+                            Object.assign(conn.videoStreamParameters[0], {
+                                maxFrameRate: Number(settings.fps),
+                                maxPixelCount: width * height,
+                                maxBitrate: 8000000,
+                                maxResolution: {
+                                    type: "fixed",
+                                    width,
+                                    height
+                                }
+                            });
+                        }
+
+                        submit({
+                            id: selected!,
+                            ...settings
+                        });
+
+                        close();
+                    }}
+                >
+                    Go Live
+                </Button>
+
+                {selected && !skipPicker ? (
+                    <Button color={Button.Colors.TRANSPARENT} onClick={() => setSelected(void 0)}>
+                        Back
+                    </Button>
+                ) : (
+                    <Button color={Button.Colors.TRANSPARENT} onClick={close}>
+                        Cancel
+                    </Button>
+                )}
+            </Modals.ModalFooter>
+        </Modals.ModalRoot>
+    );
+}
--- a/src/renderer/components/Settings.tsx
+++ b/src/renderer/components/Settings.tsx
@@ -0,0 +1,199 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import "./settings.css";
+
+import { Margins } from "@vencord/types/utils";
+import { Button, Forms, Select, Switch, Text, Toasts, useState } from "@vencord/types/webpack/common";
+import { setBadge } from "renderer/appBadge";
+import { useSettings } from "renderer/settings";
+import { isMac, isWindows } from "renderer/utils";
+import { isTruthy } from "shared/utils/guards";
+
+export default function SettingsUi() {
+    const Settings = useSettings();
+    const supportsWindowsTransparency = VesktopNative.app.supportsWindowsTransparency();
+
+    const { autostart } = VesktopNative;
+    const [autoStartEnabled, setAutoStartEnabled] = useState(autostart.isEnabled());
+
+    const allSwitches: Array<false | [keyof typeof Settings, string, string, boolean?, (() => boolean)?]> = [
+        isWindows && [
+            "discordWindowsTitleBar",
+            "Discord Titlebar",
+            "Use Discord's custom title bar instead of the Windows one. Requires a full restart."
+        ],
+        !isMac && ["tray", "Tray Icon", "Add a tray icon for Vesktop", true],
+        !isMac && [
+            "minimizeToTray",
+            "Minimize to tray",
+            "Hitting X will make Vesktop minimize to the tray instead of closing",
+            true,
+            () => Settings.tray ?? true
+        ],
+        ["arRPC", "Rich Presence", "Enables Rich Presence via arRPC", false],
+        [
+            "disableMinSize",
+            "Disable minimum window size",
+            "Allows you to make the window as small as your heart desires"
+        ],
+        ["staticTitle", "Static Title", 'Makes the window title "Vesktop" instead of changing to the current page'],
+        ["enableMenu", "Enable Menu Bar", "Enables the application menu bar. Press ALT to toggle visibility."],
+        ["splashTheming", "Splash theming", "Adapt the splash window colors to your custom theme", false],
+        [
+            "openLinksWithElectron",
+            "Open Links in app (experimental)",
+            "Opens links in a new Vesktop window instead of your web browser"
+        ],
+        ["checkUpdates", "Check for updates", "Automatically check for Vesktop updates", true]
+    ];
+
+    const switches = allSwitches.filter(isTruthy);
+
+    return (
+        <Forms.FormSection>
+            <Text variant="heading-lg/semibold" style={{ color: "var(--header-primary)" }} tag="h2">
+                Vesktop Settings
+            </Text>
+
+            <Forms.FormTitle className={Margins.top16 + " " + Margins.bottom8}>Discord Branch</Forms.FormTitle>
+            <Select
+                placeholder="Stable"
+                options={[
+                    { label: "Stable", value: "stable", default: true },
+                    { label: "Canary", value: "canary" },
+                    { label: "PTB", value: "ptb" }
+                ]}
+                closeOnSelect={true}
+                select={v => (Settings.discordBranch = v)}
+                isSelected={v => v === Settings.discordBranch}
+                serialize={s => s}
+            />
+
+            <Forms.FormDivider className={Margins.top16 + " " + Margins.bottom16} />
+
+            <Switch
+                value={autoStartEnabled}
+                onChange={async v => {
+                    await autostart[v ? "enable" : "disable"]();
+                    setAutoStartEnabled(v);
+                }}
+                note="Automatically start Vesktop on computer start-up"
+            >
+                Start With System
+            </Switch>
+
+            <Switch
+                value={Settings.appBadge ?? true}
+                onChange={v => {
+                    Settings.appBadge = v;
+                    if (v) setBadge();
+                    else VesktopNative.app.setBadgeCount(0);
+                }}
+                note="Show mention badge on the app icon"
+            >
+                Notification Badge
+            </Switch>
+
+            {switches.map(([key, text, note, def, predicate]) => (
+                <Switch
+                    value={(Settings[key as any] ?? def ?? false) && predicate?.() !== false}
+                    disabled={predicate && !predicate()}
+                    onChange={v => (Settings[key as any] = v)}
+                    note={note}
+                    key={key}
+                >
+                    {text}
+                </Switch>
+            ))}
+
+            {supportsWindowsTransparency && (
+                <>
+                    <Forms.FormTitle className={Margins.top16 + " " + Margins.bottom8}>
+                        Transparency Options
+                    </Forms.FormTitle>
+                    <Forms.FormText className={Margins.bottom8}>
+                        Requires a full restart. You will need a theme that supports transparency for this to work.
+                    </Forms.FormText>
+
+                    <Select
+                        placeholder="None"
+                        options={[
+                            {
+                                label: "None",
+                                value: "none",
+                                default: true
+                            },
+                            {
+                                label: "Mica (incorporates system theme + desktop wallpaper to paint the background)",
+                                value: "mica"
+                            },
+                            { label: "Tabbed (variant of Mica with stronger background tinting)", value: "tabbed" },
+                            {
+                                label: "Acrylic (blurs the window behind Vesktop for a translucent background)",
+                                value: "acrylic"
+                            }
+                        ]}
+                        closeOnSelect={true}
+                        select={v => (Settings.transparencyOption = v)}
+                        isSelected={v => v === Settings.transparencyOption}
+                        serialize={s => s}
+                    />
+
+                    <Forms.FormDivider className={Margins.top16 + " " + Margins.bottom16} />
+                </>
+            )}
+
+            <Forms.FormTitle>Vencord Location</Forms.FormTitle>
+            <Forms.FormText>
+                Vencord files are loaded from{" "}
+                {Settings.vencordDir ? (
+                    <a
+                        href="about:blank"
+                        onClick={e => {
+                            e.preventDefault();
+                            VesktopNative.fileManager.showItemInFolder(Settings.vencordDir!);
+                        }}
+                    >
+                        {Settings.vencordDir}
+                    </a>
+                ) : (
+                    "the default location"
+                )}
+            </Forms.FormText>
+            <div className="vcd-location-btns">
+                <Button
+                    size={Button.Sizes.SMALL}
+                    onClick={async () => {
+                        const choice = await VesktopNative.fileManager.selectVencordDir();
+                        switch (choice) {
+                            case "cancelled":
+                                return;
+                            case "invalid":
+                                Toasts.show({
+                                    message:
+                                        "You did not choose a valid Vencord install. Make sure you're selecting the dist dir!",
+                                    id: Toasts.genId(),
+                                    type: Toasts.Type.FAILURE
+                                });
+                                return;
+                        }
+                        Settings.vencordDir = choice;
+                    }}
+                >
+                    Change
+                </Button>
+                <Button
+                    size={Button.Sizes.SMALL}
+                    color={Button.Colors.RED}
+                    onClick={() => (Settings.vencordDir = void 0)}
+                >
+                    Reset
+                </Button>
+            </div>
+        </Forms.FormSection>
+    );
+}
--- a/src/renderer/components/index.ts
+++ b/src/renderer/components/index.ts
@@ -0,0 +1,8 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+export * as ScreenShare from "./ScreenSharePicker";
+export { default as Settings } from "./Settings";
--- a/src/renderer/components/screenSharePicker.css
+++ b/src/renderer/components/screenSharePicker.css
@@ -0,0 +1,124 @@
+.vcd-screen-picker-modal {
+    padding: 1em;
+}
+
+.vcd-screen-picker-header h1 {
+    margin: 0;
+}
+
+.vcd-screen-picker-footer {
+    display: flex;
+    gap: 1em;
+}
+
+.vcd-screen-picker-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 2em 1em;
+}
+
+.vcd-screen-picker-grid input {
+    appearance: none;
+    cursor: pointer;
+}
+
+.vcd-screen-picker-selected img {
+    border: 2px solid var(--brand-experiment);
+    border-radius: 3px;
+}
+
+.vcd-screen-picker-grid label {
+    overflow: hidden;
+    padding: 4px 0px;
+    cursor: pointer;
+}
+
+.vcd-screen-picker-grid label:hover {
+    outline: 2px solid var(--brand-experiment);
+}
+
+
+.vcd-screen-picker-grid div {
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    text-align: center;
+    font-weight: 600;
+    margin-inline: 0.5em;
+}
+
+.vcd-screen-picker-card {
+    padding: 0.5em;
+    box-sizing: border-box;
+}
+
+.vcd-screen-picker-preview img {
+    width: 100%;
+    margin-bottom: 0.5em;
+}
+
+.vcd-screen-picker-preview {
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    margin-bottom: 1em;
+}
+
+.vcd-screen-picker-radio input {
+    display: none;
+}
+
+.vcd-screen-picker-radio {
+    background-color: var(--background-secondary);
+    border: 1px solid var(--primary-800);
+    padding: 0.3em;
+    cursor: pointer;
+}
+
+.vcd-screen-picker-radio h2 {
+    margin: 0;
+}
+
+.vcd-screen-picker-radio[data-checked="true"] {
+    background-color: var(--brand-experiment);
+    border-color: var(--brand-experiment);
+}
+
+.vcd-screen-picker-radio[data-checked="true"] h2 {
+    color: var(--interactive-active);
+}
+
+.vcd-screen-picker-quality {
+    display: flex;
+    gap: 1em;
+
+    margin-bottom: 0.5em;
+}
+
+.vcd-screen-picker-quality section {
+    flex: 1 1 auto;
+}
+
+.vcd-screen-picker-radios {
+    display: flex;
+    width: 100%;
+    border-radius: 3px;
+}
+
+.vcd-screen-picker-radios label {
+    flex: 1 1 auto;
+    text-align: center;
+}
+
+.vcd-screen-picker-radios label:first-child {
+    border-radius: 3px 0 0 3px;
+}
+
+.vcd-screen-picker-radios label:last-child {
+    border-radius: 0 3px 3px 0;
+}
+
+.vcd-screen-picker-audio {
+    margin-bottom: 0;
+}
--- a/src/renderer/components/settings.css
+++ b/src/renderer/components/settings.css
@@ -0,0 +1,6 @@
+.vcd-location-btns {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 0.5em;
+    margin-top: 0.5em;
+}
--- a/src/renderer/constants.ts
+++ b/src/renderer/constants.ts
--- a/src/renderer/fixes.ts
+++ b/src/renderer/fixes.ts
@@ -1,5 +1,14 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import "./hideGarbage.css";
-import { isFirstRun, localStorage } from "./utils";
+
+import { waitFor } from "@vencord/types/webpack";
+
+import { isFirstRun, isWindows, localStorage } from "./utils";

 // Make clicking Notifications focus the window
 const originalSetOnClick = Object.getOwnPropertyDescriptor(Notification.prototype, "onclick")!.set!;
@@ -7,18 +16,29 @@ Object.defineProperty(Notification.prototype, "onclick", {
    set(onClick) {
        originalSetOnClick.call(this, function (this: unknown) {
            onClick.apply(this, arguments);
-            VencordDesktop.win.focus();
+            VesktopNative.win.focus();
        });
    },
    configurable: true
 });

-// Enable Desktop Notifications by default
 if (isFirstRun) {
    // Hide "Download Discord Desktop now!!!!" banner
    localStorage.setItem("hideNag", "true");

-    Vencord.Webpack.waitFor("setDesktopType", m => {
+    // Enable Desktop Notifications by default
+    waitFor("setDesktopType", m => {
        m.setDesktopType("all");
    });
 }
+
+// FIXME: Remove eventually.
+// Originally, Vencord always used a Windows user agent. This seems to cause captchas
+// Now, we use a platform specific UA - HOWEVER, discord FOR SOME REASON????? caches
+// device props in localStorage. This code fixes their cache to properly update the platform in SuperProps
+if (!isWindows)
+    try {
+        const deviceProperties = localStorage.getItem("deviceProperties");
+        if (deviceProperties && JSON.parse(deviceProperties).os === "Windows")
+            localStorage.removeItem("deviceProperties");
+    } catch {}
--- a/src/renderer/hideGarbage.css
+++ b/src/renderer/hideGarbage.css
@@ -1,5 +1,5 @@
 /* Download Desktop button in guilds list */
-[class|=listItem]:has([data-list-item-id=guildsnav___app-download-button]),
-[class|=listItem]:has(+ [class|=listItem] [data-list-item-id=guildsnav___app-download-button]) {
+[class^=listItem_]:has([data-list-item-id=guildsnav___app-download-button]),
+[class^=listItem_]:has(+ [class^=listItem_] [data-list-item-id=guildsnav___app-download-button]) {
    display: none;
 }
--- a/src/renderer/index.ts
+++ b/src/renderer/index.ts
@@ -1,3 +1,59 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import "./fixes";
+import "./appBadge";
+import "./patches";
+import "./themedSplash";

 console.log("read if cute :3");
+
+export * as Components from "./components";
+import { findByPropsLazy } from "@vencord/types/webpack";
+import { FluxDispatcher } from "@vencord/types/webpack/common";
+
+import SettingsUi from "./components/Settings";
+import { Settings } from "./settings";
+export { Settings };
+
+const InviteActions = findByPropsLazy("resolveInvite");
+
+export async function openInviteModal(code: string) {
+    const { invite } = await InviteActions.resolveInvite(code, "Desktop Modal");
+    if (!invite) return false;
+
+    VesktopNative.win.focus();
+
+    FluxDispatcher.dispatch({
+        type: "INVITE_MODAL_OPEN",
+        invite,
+        code,
+        context: "APP"
+    });
+
+    return true;
+}
+
+const customSettingsSections = (
+    Vencord.Plugins.plugins.Settings as any as { customSections: ((ID: Record<string, unknown>) => any)[] }
+).customSections;
+
+customSettingsSections.push(() => ({
+    section: "Vesktop",
+    label: "Vesktop Settings",
+    element: SettingsUi,
+    className: "vc-vesktop-settings"
+}));
+
+const arRPC = Vencord.Plugins.plugins["WebRichPresence (arRPC)"] as any as {
+    handleEvent(e: MessageEvent): void;
+};
+
+VesktopNative.arrpc.onActivity(data => {
+    if (!Settings.store.arRPC) return;
+
+    arRPC.handleEvent(new MessageEvent("message", { data }));
+});
--- a/src/renderer/patches/index.ts
+++ b/src/renderer/patches/index.ts
@@ -0,0 +1,11 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+// TODO: Possibly auto generate glob if we have more patches in the future
+import "./spellCheck";
+import "./platformClass";
+import "./windowsTitleBar";
+import "./screenShareAudio";
--- a/src/renderer/patches/platformClass.tsx
+++ b/src/renderer/patches/platformClass.tsx
@@ -0,0 +1,29 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { Settings } from "renderer/settings";
+import { isMac, isWindows } from "renderer/utils";
+
+import { addPatch } from "./shared";
+
+addPatch({
+    patches: [
+        {
+            find: "platform-web",
+            replacement: {
+                // eslint-disable-next-line no-useless-escape
+                match: /(?<=" platform-overlay"\):)\i/,
+                replace: "$self.getPlatformClass()"
+            }
+        }
+    ],
+
+    getPlatformClass() {
+        if (isMac) return "platform-osx";
+        if (isWindows && Settings.store.discordWindowsTitleBar) return "platform-win";
+        return "platform-web";
+    }
+});
--- a/src/renderer/patches/screenShareAudio.ts
+++ b/src/renderer/patches/screenShareAudio.ts
@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { isLinux } from "renderer/utils";
+
+if (isLinux) {
+    const original = navigator.mediaDevices.getDisplayMedia;
+
+    async function getVirtmic() {
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            const audioDevice = devices.find(({ label }) => label === "vencord-screen-share");
+            return audioDevice?.deviceId;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    navigator.mediaDevices.getDisplayMedia = async function (opts) {
+        const stream = await original.call(this, opts);
+        const id = await getVirtmic();
+
+        if (id) {
+            const audio = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    deviceId: {
+                        exact: id
+                    },
+                    autoGainControl: false,
+                    echoCancellation: false,
+                    noiseSuppression: false
+                }
+            });
+            audio.getAudioTracks().forEach(t => stream.addTrack(t));
+        }
+
+        return stream;
+    };
+}
--- a/src/renderer/patches/shared.ts
+++ b/src/renderer/patches/shared.ts
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { Patch } from "@vencord/types/utils/types";
+
+window.VCDP = {};
+
+interface PatchData {
+    patches: Omit<Patch, "plugin">[];
+    [key: string]: any;
+}
+
+export function addPatch<P extends PatchData>(p: P) {
+    const { patches, ...globals } = p;
+
+    for (const patch of patches as Patch[]) {
+        if (!Array.isArray(patch.replacement)) patch.replacement = [patch.replacement];
+        for (const r of patch.replacement) {
+            if (typeof r.replace === "string") r.replace = r.replace.replaceAll("$self", "VCDP");
+        }
+
+        patch.plugin = "Vesktop";
+        Vencord.Plugins.patches.push(patch);
+    }
+
+    Object.assign(VCDP, globals);
+}
--- a/src/renderer/patches/spellCheck.tsx
+++ b/src/renderer/patches/spellCheck.tsx
@@ -0,0 +1,83 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { addContextMenuPatch } from "@vencord/types/api/ContextMenu";
+import { findStoreLazy } from "@vencord/types/webpack";
+import { ContextMenu, FluxDispatcher, Menu } from "@vencord/types/webpack/common";
+
+import { addPatch } from "./shared";
+
+let word: string;
+let corrections: string[];
+
+const SpellCheckStore = findStoreLazy("SpellcheckStore");
+
+// Make spellcheck suggestions work
+addPatch({
+    patches: [
+        {
+            find: ".enableSpellCheck)",
+            replacement: {
+                // if (isDesktop) { DiscordNative.onSpellcheck(openMenu(props)) } else { e.preventDefault(); openMenu(props) }
+                match: /else (.{1,3})\.preventDefault\(\),(.{1,3}\(.{1,3}\))(?<=:(.{1,3})\.enableSpellCheck\).+?)/,
+                // ... else { $self.onSlateContext(() => openMenu(props)) }
+                replace: "else {$self.onSlateContext($1, $3?.enableSpellCheck, () => $2)}"
+            }
+        }
+    ],
+
+    onSlateContext(e: MouseEvent, hasSpellcheck: boolean | undefined, openMenu: () => void) {
+        if (!hasSpellcheck) {
+            e.preventDefault();
+            openMenu();
+            return;
+        }
+
+        const cb = (w: string, c: string[]) => {
+            VesktopNative.spellcheck.offSpellcheckResult(cb);
+            word = w;
+            corrections = c;
+            openMenu();
+        };
+        VesktopNative.spellcheck.onSpellcheckResult(cb);
+    }
+});
+
+addContextMenuPatch("textarea-context", children => () => {
+    const hasCorrections = Boolean(word && corrections?.length);
+
+    children.push(
+        <Menu.MenuGroup>
+            {hasCorrections && (
+                <>
+                    {corrections.map(c => (
+                        <Menu.MenuItem
+                            id={"vcd-spellcheck-suggestion-" + c}
+                            label={c}
+                            action={() => VesktopNative.spellcheck.replaceMisspelling(c)}
+                        />
+                    ))}
+                    <Menu.MenuSeparator />
+                    <Menu.MenuItem
+                        id="vcd-spellcheck-learn"
+                        label={`Add ${word} to dictionary`}
+                        action={() => VesktopNative.spellcheck.addToDictionary(word)}
+                    />
+                </>
+            )}
+            <Menu.MenuCheckboxItem
+                id="vcd-spellcheck-enabled"
+                label="Enable Spellcheck"
+                checked={SpellCheckStore.isEnabled()}
+                action={() => {
+                    FluxDispatcher.dispatch({ type: "SPELLCHECK_TOGGLE" });
+                    // Haven't found a good way to update state, so just close for now 🤷‍♀️
+                    ContextMenu.close();
+                }}
+            />
+        </Menu.MenuGroup>
+    );
+});
--- a/src/renderer/patches/windowsTitleBar.tsx
+++ b/src/renderer/patches/windowsTitleBar.tsx
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { Settings } from "renderer/settings";
+
+import { addPatch } from "./shared";
+
+if (Settings.store.discordWindowsTitleBar)
+    addPatch({
+        patches: [
+            {
+                find: ".wordmarkWindows",
+                replacement: [
+                    {
+                        // TODO: Fix eslint rule
+                        // eslint-disable-next-line no-useless-escape
+                        match: /case \i\.\i\.WINDOWS:/,
+                        replace: 'case "WEB":'
+                    },
+                    ...["close", "minimize", "maximize"].map(op => ({
+                        match: new RegExp(String.raw`\i\.\i\.${op}\b`),
+                        replace: `VesktopNative.win.${op}`
+                    }))
+                ]
+            }
+        ]
+    });
--- a/src/renderer/settings.ts
+++ b/src/renderer/settings.ts
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { useEffect, useReducer } from "@vencord/types/webpack/common";
+import { SettingsStore } from "shared/utils/SettingsStore";
+
+export const Settings = new SettingsStore(VesktopNative.settings.get());
+Settings.addGlobalChangeListener((o, p) => VesktopNative.settings.set(o, p));
+
+export function useSettings() {
+    const [, update] = useReducer(x => x + 1, 0);
+
+    useEffect(() => {
+        Settings.addGlobalChangeListener(update);
+
+        return () => Settings.removeGlobalChangeListener(update);
+    }, []);
+
+    return Settings.store;
+}
+
+export function getValueAndOnChange(key: keyof typeof Settings.store) {
+    return {
+        value: Settings.store[key] as any,
+        onChange: (value: any) => (Settings.store[key] = value)
+    };
+}
--- a/src/renderer/themedSplash.ts
+++ b/src/renderer/themedSplash.ts
@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { Settings } from "./settings";
+
+function isValidColor(color: CSSStyleValue | undefined): color is CSSUnparsedValue & { [0]: string } {
+    return color instanceof CSSUnparsedValue && typeof color[0] === "string" && CSS.supports("color", color[0]);
+}
+
+function resolveColor(color: string) {
+    const span = document.createElement("span");
+    span.style.color = color;
+    span.style.display = "none";
+
+    document.body.append(span);
+    const rgbColor = getComputedStyle(span).color;
+    span.remove();
+
+    return rgbColor;
+}
+
+const updateSplashColors = () => {
+    const bodyStyles = document.body.computedStyleMap();
+
+    const color = bodyStyles.get("--text-normal");
+    const backgroundColor = bodyStyles.get("--background-primary");
+
+    if (isValidColor(color)) {
+        Settings.store.splashColor = resolveColor(color[0]);
+    }
+
+    if (isValidColor(backgroundColor)) {
+        Settings.store.splashBackground = resolveColor(backgroundColor[0]);
+    }
+};
+
+if (document.readyState === "complete") {
+    updateSplashColors();
+} else {
+    window.addEventListener("load", updateSplashColors);
+}
+
+window.addEventListener("beforeunload", updateSplashColors);
--- a/src/renderer/utils.ts
+++ b/src/renderer/utils.ts
@@ -1,4 +1,10 @@
-export const localStorage = window.vcdLS = window.localStorage;
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+export const { localStorage } = window;

 export const isFirstRun = (() => {
    const key = "VCD_FIRST_RUN";
@@ -6,3 +12,9 @@ export const isFirstRun = (() => {
    localStorage.setItem(key, "false");
    return true;
 })();
+
+const { platform } = navigator;
+
+export const isWindows = platform.startsWith("Win");
+export const isMac = platform.startsWith("Mac");
+export const isLinux = platform.startsWith("Linux");
--- a/src/shared/IpcEvents.ts
+++ b/src/shared/IpcEvents.ts
@@ -1,10 +1,51 @@
-export const GET_VENCORD_PRELOAD_FILE = "VCD_GET_VC_PRELOAD_FILE";
-export const GET_RENDERER_SCRIPT = "VCD_GET_RENDERER_SCRIPT";
-export const GET_RENDERER_STYLES = "VCD_GET_RENDERER_STYLES";
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */

-export const RELAUNCH = "VCD_RELAUNCH";
-export const FOCUS = "VC_FOCUS";
+export const enum IpcEvents {
+    GET_VENCORD_PRELOAD_FILE = "VCD_GET_VC_PRELOAD_FILE",
+    GET_VENCORD_RENDERER_SCRIPT = "VCD_GET_VC_RENDERER_SCRIPT",
+    GET_RENDERER_SCRIPT = "VCD_GET_RENDERER_SCRIPT",
+    GET_RENDERER_CSS_FILE = "VCD_GET_RENDERER_CSS_FILE",

-export const SHOW_ITEM_IN_FOLDER = "VCD_SHOW_ITEM_IN_FOLDER";
-export const GET_SETTINGS = "VCD_GET_SETTINGS";
-export const SET_SETTINGS = "VCD_SET_SETTINGS";
+    GET_VERSION = "VCD_GET_VERSION",
+    SUPPORTS_WINDOWS_TRANSPARENCY = "VCD_SUPPORTS_WINDOWS_TRANSPARENCY",
+
+    RELAUNCH = "VCD_RELAUNCH",
+    CLOSE = "VCD_CLOSE",
+    FOCUS = "VCD_FOCUS",
+    MINIMIZE = "VCD_MINIMIZE",
+    MAXIMIZE = "VCD_MAXIMIZE",
+
+    SHOW_ITEM_IN_FOLDER = "VCD_SHOW_ITEM_IN_FOLDER",
+    GET_SETTINGS = "VCD_GET_SETTINGS",
+    SET_SETTINGS = "VCD_SET_SETTINGS",
+
+    SELECT_VENCORD_DIR = "VCD_SELECT_VENCORD_DIR",
+
+    UPDATER_GET_DATA = "VCD_UPDATER_GET_DATA",
+    UPDATER_DOWNLOAD = "VCD_UPDATER_DOWNLOAD",
+    UPDATE_IGNORE = "VCD_UPDATE_IGNORE",
+
+    SPELLCHECK_SET_LANGUAGES = "VCD_SPELLCHECK_SET_LANGUAGES",
+    SPELLCHECK_RESULT = "VCD_SPELLCHECK_RESULT",
+    SPELLCHECK_REPLACE_MISSPELLING = "VCD_SPELLCHECK_REPLACE_MISSPELLING",
+    SPELLCHECK_ADD_TO_DICTIONARY = "VCD_SPELLCHECK_ADD_TO_DICTIONARY",
+
+    SET_BADGE_COUNT = "VCD_SET_BADGE_COUNT",
+
+    CAPTURER_GET_LARGE_THUMBNAIL = "VCD_CAPTURER_GET_LARGE_THUMBNAIL",
+
+    AUTOSTART_ENABLED = "VCD_AUTOSTART_ENABLED",
+    ENABLE_AUTOSTART = "VCD_ENABLE_AUTOSTART",
+    DISABLE_AUTOSTART = "VCD_DISABLE_AUTOSTART",
+
+    VIRT_MIC_LIST = "VCD_VIRT_MIC_LIST",
+    VIRT_MIC_START = "VCD_VIRT_MIC_START",
+    VIRT_MIC_START_SYSTEM = "VCD_VIRT_MIC_START_ALL",
+    VIRT_MIC_STOP = "VCD_VIRT_MIC_STOP",
+
+    ARRPC_ACTIVITY = "VCD_ARRPC_ACTIVITY"
+}
--- a/src/shared/browserWinProperties.ts
+++ b/src/shared/browserWinProperties.ts
@@ -0,0 +1,18 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import type { BrowserWindowConstructorOptions } from "electron";
+
+export const SplashProps: BrowserWindowConstructorOptions = {
+    transparent: true,
+    frame: false,
+    height: 350,
+    width: 300,
+    center: true,
+    resizable: false,
+    maximizable: false,
+    alwaysOnTop: true
+};
--- a/src/shared/paths.ts
+++ b/src/shared/paths.ts
@@ -1,4 +1,12 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
 import { join } from "path";

-export const STATIC_DIR = join(__dirname, "..", "..", "static");
-export const ICON_PATH = join(STATIC_DIR, "icon.png");
+export const STATIC_DIR = /* @__PURE__ */ join(__dirname, "..", "..", "static");
+export const VIEW_DIR = /* @__PURE__ */ join(STATIC_DIR, "views");
+export const BADGE_DIR = /* @__PURE__ */ join(STATIC_DIR, "badges");
+export const ICON_PATH = /* @__PURE__ */ join(STATIC_DIR, "icon.png");
--- a/src/shared/settings.d.ts
+++ b/src/shared/settings.d.ts
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import type { Rectangle } from "electron";
+
+export interface Settings {
+    discordBranch?: "stable" | "canary" | "ptb";
+    vencordDir?: string;
+    transparencyOption?: "none" | "mica" | "tabbed" | "acrylic";
+    tray?: boolean;
+    minimizeToTray?: boolean;
+    openLinksWithElectron?: boolean;
+    staticTitle?: boolean;
+    enableMenu?: boolean;
+    arRPC?: boolean;
+    appBadge?: boolean;
+    discordWindowsTitleBar?: boolean;
+
+    maximized?: boolean;
+    minimized?: boolean;
+    windowBounds?: Rectangle;
+    disableMinSize?: boolean;
+
+    checkUpdates?: boolean;
+    skippedUpdate?: string;
+    firstLaunch?: boolean;
+
+    splashTheming?: boolean;
+    splashColor?: string;
+    splashBackground?: string;
+
+    steamOSLayoutVersion?: number;
+}
--- a/src/shared/utils/SettingsStore.ts
+++ b/src/shared/utils/SettingsStore.ts
@@ -0,0 +1,147 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { LiteralUnion } from "type-fest";
+
+// Resolves a possibly nested prop in the form of "some.nested.prop" to type of T.some.nested.prop
+type ResolvePropDeep<T, P> = P extends `${infer Pre}.${infer Suf}`
+    ? Pre extends keyof T
+        ? ResolvePropDeep<T[Pre], Suf>
+        : any
+    : P extends keyof T
+    ? T[P]
+    : any;
+
+/**
+ * The SettingsStore allows you to easily create a mutable store that
+ * has support for global and path-based change listeners.
+ */
+export class SettingsStore<T extends object> {
+    private pathListeners = new Map<string, Set<(newData: any) => void>>();
+    private globalListeners = new Set<(newData: T, path: string) => void>();
+
+    /**
+     * The store object. Making changes to this object will trigger the applicable change listeners
+     */
+    public declare store: T;
+    /**
+     * The plain data. Changes to this object will not trigger any change listeners
+     */
+    public declare plain: T;
+
+    public constructor(plain: T) {
+        this.plain = plain;
+        this.store = this.makeProxy(plain);
+    }
+
+    private makeProxy(object: any, root: T = object, path: string = "") {
+        const self = this;
+
+        return new Proxy(object, {
+            get(target, key: string) {
+                const v = target[key];
+
+                if (typeof v === "object" && v !== null && !Array.isArray(v))
+                    return self.makeProxy(v, root, `${path}${path && "."}${key}`);
+
+                return v;
+            },
+            set(target, key: string, value) {
+                if (target[key] === value) return true;
+
+                Reflect.set(target, key, value);
+                const setPath = `${path}${path && "."}${key}`;
+
+                self.globalListeners.forEach(cb => cb(root, setPath));
+                self.pathListeners.get(setPath)?.forEach(cb => cb(value));
+
+                return true;
+            }
+        });
+    }
+
+    /**
+     * Set the data of the store.
+     * This will update this.store and this.plain (and old references to them will be stale! Avoid storing them in variables)
+     *
+     * Additionally, all global listeners (and those for pathToNotify, if specified) will be called with the new data
+     * @param value New data
+     * @param pathToNotify Optional path to notify instead of globally. Used to transfer path via ipc
+     */
+    public setData(value: T, pathToNotify?: string) {
+        this.plain = value;
+        this.store = this.makeProxy(value);
+
+        if (pathToNotify) {
+            let v = value;
+
+            const path = pathToNotify.split(".");
+            for (const p of path) {
+                if (!v) {
+                    console.warn(
+                        `Settings#setData: Path ${pathToNotify} does not exist in new data. Not dispatching update`
+                    );
+                    return;
+                }
+                v = v[p];
+            }
+
+            this.pathListeners.get(pathToNotify)?.forEach(cb => cb(v));
+        }
+
+        this.globalListeners.forEach(cb => cb(value, ""));
+    }
+
+    /**
+     * Add a global change listener, that will fire whenever any setting is changed
+     */
+    public addGlobalChangeListener(cb: (data: T, path: string) => void) {
+        this.globalListeners.add(cb);
+    }
+
+    /**
+     * Add a scoped change listener that will fire whenever a setting matching the specified path is changed.
+     *
+     * For example if path is `"foo.bar"`, the listener will fire on
+     * ```js
+     * Setting.store.foo.bar = "hi"
+     * ```
+     * but not on
+     * ```js
+     * Setting.store.foo.baz = "hi"
+     * ```
+     * @param path
+     * @param cb
+     */
+    public addChangeListener<P extends LiteralUnion<keyof T, string>>(
+        path: P,
+        cb: (data: ResolvePropDeep<T, P>) => void
+    ) {
+        const listeners = this.pathListeners.get(path as string) ?? new Set();
+        listeners.add(cb);
+        this.pathListeners.set(path as string, listeners);
+    }
+
+    /**
+     * Remove a global listener
+     * @see {@link addGlobalChangeListener}
+     */
+    public removeGlobalChangeListener(cb: (data: T, path: string) => void) {
+        this.globalListeners.delete(cb);
+    }
+
+    /**
+     * Remove a scoped listener
+     * @see {@link addChangeListener}
+     */
+    public removeChangeListener(path: LiteralUnion<keyof T, string>, cb: (data: any) => void) {
+        const listeners = this.pathListeners.get(path as string);
+        if (!listeners) return;
+
+        listeners.delete(cb);
+        if (!listeners.size) this.pathListeners.delete(path as string);
+    }
+}
--- a/src/shared/utils/debounce.ts
+++ b/src/shared/utils/debounce.ts
@@ -1,7 +1,21 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+/**
+ * Returns a new function that will only be called after the given delay.
+ * Subsequent calls will cancel the previous timeout and start a new one from 0
+ *
+ * Useful for grouping multiple calls into one
+ */
 export function debounce<T extends Function>(func: T, delay = 300): T {
    let timeout: NodeJS.Timeout;
    return function (...args: any[]) {
        clearTimeout(timeout);
-        timeout = setTimeout(() => { func(...args); }, delay);
+        timeout = setTimeout(() => {
+            func(...args);
+        }, delay);
    } as any;
 }
--- a/src/shared/utils/guards.ts
+++ b/src/shared/utils/guards.ts
@@ -0,0 +1,13 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+export function isTruthy<T>(item: T): item is Exclude<T, 0 | "" | false | null | undefined> {
+    return Boolean(item);
+}
+
+export function isNonNullish<T>(item: T): item is Exclude<T, null | undefined> {
+    return item != null;
+}
--- a/src/shared/utils/once.ts
+++ b/src/shared/utils/once.ts
@@ -1,3 +1,14 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+/**
+ * Wraps the given function so that it can only be called once
+ * @param fn Function to wrap
+ * @returns New function that can only be called once
+ */
 export function once<T extends Function>(fn: T): T {
    let called = false;
    return function (this: any, ...args: any[]) {
--- a/src/shared/utils/sleep.ts
+++ b/src/shared/utils/sleep.ts
@@ -0,0 +1,9 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+export function sleep(ms: number): Promise<void> {
+    return new Promise(r => setTimeout(r, ms));
+}
--- a/src/updater/main.ts
+++ b/src/updater/main.ts
@@ -0,0 +1,119 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { app, BrowserWindow, shell } from "electron";
+import { Settings } from "main/settings";
+import { handle } from "main/utils/ipcWrappers";
+import { makeLinksOpenExternally } from "main/utils/makeLinksOpenExternally";
+import { githubGet, ReleaseData } from "main/utils/vencordLoader";
+import { join } from "path";
+import { IpcEvents } from "shared/IpcEvents";
+import { ICON_PATH, VIEW_DIR } from "shared/paths";
+
+export interface UpdateData {
+    currentVersion: string;
+    latestVersion: string;
+    release: ReleaseData;
+}
+
+let updateData: UpdateData;
+
+handle(IpcEvents.UPDATER_GET_DATA, () => updateData);
+handle(IpcEvents.UPDATER_DOWNLOAD, () => {
+    const portable = !!process.env.PORTABLE_EXECUTABLE_FILE;
+
+    const { assets } = updateData.release;
+    const url = (() => {
+        switch (process.platform) {
+            case "win32":
+                return assets.find(a => {
+                    if (!a.name.endsWith(".exe")) return false;
+
+                    const isSetup = a.name.includes("Setup");
+                    return portable ? !isSetup : isSetup;
+                })!.browser_download_url;
+            case "darwin":
+                return assets.find(a =>
+                    process.arch === "arm64"
+                        ? a.name.endsWith("-arm64-mac.zip")
+                        : a.name.endsWith("-mac.zip") && !a.name.includes("arm64")
+                )!.browser_download_url;
+            case "linux":
+                return updateData.release.html_url;
+            default:
+                throw new Error(`Unsupported platform: ${process.platform}`);
+        }
+    })();
+
+    shell.openExternal(url);
+});
+
+handle(IpcEvents.UPDATE_IGNORE, () => {
+    Settings.store.skippedUpdate = updateData.latestVersion;
+});
+
+function isOutdated(oldVersion: string, newVersion: string) {
+    const oldParts = oldVersion.split(".");
+    const newParts = newVersion.split(".");
+
+    if (oldParts.length !== newParts.length)
+        throw new Error(`Incompatible version strings (old: ${oldVersion}, new: ${newVersion})`);
+
+    for (let i = 0; i < oldParts.length; i++) {
+        const oldPart = Number(oldParts[i]);
+        const newPart = Number(newParts[i]);
+
+        if (isNaN(oldPart) || isNaN(newPart))
+            throw new Error(`Invalid version string (old: ${oldVersion}, new: ${newVersion})`);
+
+        if (oldPart < newPart) return true;
+        if (oldPart > newPart) return false;
+    }
+
+    return false;
+}
+
+export async function checkUpdates() {
+    if (Settings.store.checkUpdates === false) return;
+
+    try {
+        const raw = await githubGet("/repos/Vencord/Vesktop/releases/latest");
+        const data = JSON.parse(raw.toString("utf-8")) as ReleaseData;
+
+        const oldVersion = app.getVersion();
+        const newVersion = data.tag_name.replace(/^v/, "");
+        updateData = {
+            currentVersion: oldVersion,
+            latestVersion: newVersion,
+            release: data
+        };
+
+        if (Settings.store.skippedUpdate !== newVersion && isOutdated(oldVersion, newVersion)) {
+            openNewUpdateWindow();
+        }
+    } catch (e) {
+        console.error("AppUpdater: Failed to check for updates\n", e);
+    }
+}
+
+function openNewUpdateWindow() {
+    const win = new BrowserWindow({
+        width: 500,
+        autoHideMenuBar: true,
+        alwaysOnTop: true,
+        webPreferences: {
+            preload: join(__dirname, "updaterPreload.js"),
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: true
+        },
+        icon: ICON_PATH
+    });
+
+    makeLinksOpenExternally(win);
+
+    win.loadFile(join(VIEW_DIR, "updater.html"));
+}
--- a/src/updater/preload.ts
+++ b/src/updater/preload.ts
@@ -0,0 +1,21 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { contextBridge } from "electron";
+import { invoke } from "preload/typedIpc";
+import { IpcEvents } from "shared/IpcEvents";
+
+import type { UpdateData } from "./main";
+
+contextBridge.exposeInMainWorld("Updater", {
+    getData: () => invoke<UpdateData>(IpcEvents.UPDATER_GET_DATA),
+    download: () => {
+        invoke<void>(IpcEvents.UPDATER_DOWNLOAD);
+        invoke<void>(IpcEvents.CLOSE);
+    },
+    ignore: () => invoke<void>(IpcEvents.UPDATE_IGNORE),
+    close: () => invoke<void>(IpcEvents.CLOSE)
+});
--- a/static/about.html
+++ b/static/about.html
@@ -1,34 +0,0 @@
-<head>
-    <style>
-        body {
-            padding: 2em;
-            font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell,
-                "Open Sans", "Helvetica Neue", sans-serif;
-        }
-
-        h1 {
-            text-align: center;
-        }
-    </style>
-</head>
-
-<body>
-    <h1>About Vencord Desktop</h1>
-    <p>
-        Vencord Desktop is a free/libre cross platform desktop app aiming to give you a snappier Discord experience with
-        Vencord pre-installed
-    </p>
-
-    <h2>Links</h2>
-    <ul>
-        <li>
-            <a href="https://vencord.dev">Vencord Website</a>
-        </li>
-        <li>
-            <a href="https://github.com/Vencord/Desktop" target="_blank">Source Code</a>
-        </li>
-        <li>
-            <a href="https://github.com/Vencord/Desktop/issues" target="_blank">Report bugs / Request features</a>
-        </li>
-    </ul>
-</body>
--- a/static/badges/1.ico
+++ b/static/badges/1.ico
--- a/static/badges/10.ico
+++ b/static/badges/10.ico
--- a/static/badges/11.ico
+++ b/static/badges/11.ico
--- a/static/badges/2.ico
+++ b/static/badges/2.ico
--- a/static/badges/3.ico
+++ b/static/badges/3.ico
--- a/static/badges/4.ico
+++ b/static/badges/4.ico
--- a/static/badges/5.ico
+++ b/static/badges/5.ico
--- a/static/badges/6.ico
+++ b/static/badges/6.ico
--- a/static/badges/7.ico
+++ b/static/badges/7.ico
--- a/static/badges/8.ico
+++ b/static/badges/8.ico
--- a/static/badges/9.ico
+++ b/static/badges/9.ico
--- a/static/dist/.gitignore
+++ b/static/dist/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
--- a/static/shiggy.gif
+++ b/static/shiggy.gif
--- a/static/splash.html
+++ b/static/splash.html
@@ -1,29 +0,0 @@
-<head>
-  <style>
-    body {
-      margin: 0;
-      padding: 0;
-    }
-
-    .wrapper {
-      height: 100%;
-      display: flex;
-      justify-content: center;
-      align-items: center;
-      background-color: hsl(223 6.7% 20.6%);
-      border-radius: 6px;
-    }
-
-    p {
-      color: white;
-      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell,
-        "Open Sans", "Helvetica Neue", sans-serif;
-    }
-  </style>
-</head>
-
-<body>
-  <div class="wrapper">
-    <p>Loading...</p>
-  </div>
-</body>
--- a/static/views/about.html
+++ b/static/views/about.html
@@ -0,0 +1,75 @@
+<head>
+    <link rel="stylesheet" href="./style.css" type="text/css" />
+
+    <style>
+        body {
+            padding: 2em;
+        }
+
+        h1 {
+            text-align: center;
+        }
+    </style>
+</head>
+
+<body>
+    <h1 id="title">Vesktop</h1>
+    <p>
+        Vesktop is a free/libre cross platform desktop app aiming to give you a snappier Discord experience with Vencord
+        pre-installed
+    </p>
+
+    <section>
+        <h2>Links</h2>
+        <ul>
+            <li>
+                <a href="https://vencord.dev" target="_blank">Vencord Website</a>
+            </li>
+            <li>
+                <a href="https://github.com/Vencord/Vesktop" target="_blank">Source Code</a>
+            </li>
+            <li>
+                <a href="https://github.com/Vencord/Vesktop/issues" target="_blank">Report bugs / Request features</a>
+            </li>
+        </ul>
+    </section>
+
+    <section>
+        <h2>Acknowledgements</h2>
+        <p>These awesome libraries empower Vesktop</p>
+        <ul>
+            <li>
+                <a href="https://github.com/electron/electron" target="_blank">Electron</a>
+                - Build cross-platform desktop apps with JavaScript, HTML, and CSS
+            </li>
+            <li>
+                <a href="https://github.com/electron-userland/electron-builder" target="_blank">Electron Builder</a>
+                - A complete solution to package and build a ready for distribution Electron app with “auto update”
+                support out of the box
+            </li>
+            <li>
+                <a href="https://github.com/OpenAsar/arrpc" target="_blank">arrpc</a>
+                - An open implementation of Discord's Rich Presence server
+            </li>
+            <li>
+                <a href="https://github.com/Soundux/rohrkabel" target="_blank">rohrkabel</a>
+                - A C++ RAII Pipewire-API Wrapper 
+            </li>
+            <li>
+                And many
+                <a href="https://github.com/Vencord/Vesktop/blob/main/pnpm-lock.yaml" target="_blank"
+                    >more awesome open source libraries</a
+                >
+            </li>
+        </ul>
+    </section>
+</body>
+
+<script type="module">
+    const data = await Updater.getData();
+    if (data.currentVersion) {
+        const title = document.getElementById("title");
+
+        title.textContent += ` v${data.currentVersion}`;
+    }
+</script>
--- a/static/views/first-launch.html
+++ b/static/views/first-launch.html
@@ -0,0 +1,170 @@
+<head>
+    <link rel="stylesheet" href="./style.css" type="text/css" />
+
+    <style>
+        body {
+            height: 100vh;
+
+            padding: 1.5em;
+            padding-bottom: 1em;
+
+            border: 1px solid var(--fg-semi-trans);
+            border-top: none;
+            display: flex;
+            flex-direction: column;
+            box-sizing: border-box;
+        }
+
+        select {
+            background: var(--bg);
+            color: var(--fg);
+            padding: 0.3em;
+            margin: -0.3em;
+            border-radius: 6px;
+        }
+
+        h1 {
+            margin: 0.4em 0 0;
+        }
+
+        p {
+            margin: 1em 0 2em;
+        }
+
+        form {
+            display: grid;
+            gap: 1em;
+            margin: 0;
+        }
+
+        label {
+            position: relative;
+            display: flex;
+            justify-content: space-between;
+        }
+
+        label:has(input[type="checkbox"]),
+        select {
+            cursor: pointer;
+        }
+
+        label:not(:last-child)::after {
+            content: "";
+            position: absolute;
+            bottom: -10px;
+            width: 100%;
+            height: 1px;
+            background-color: var(--fg-secondary);
+            opacity: 0.5;
+        }
+
+        label div {
+            display: grid;
+            gap: 0.2em;
+        }
+
+        label h2 {
+            margin: 0;
+            font-weight: normal;
+            font-size: 1.1rem;
+            line-height: 1rem;
+        }
+
+        label span {
+            font-size: 0.9rem;
+            font-weight: 400;
+            color: var(--fg-secondary);
+        }
+
+        #buttons {
+            display: flex;
+            justify-content: end;
+            gap: 0.5em;
+            margin-top: auto;
+        }
+
+        button {
+            padding: 0.6em;
+            background: red;
+            color: white;
+            border-radius: 6px;
+            border: none;
+            cursor: pointer;
+            transition: 200ms filter;
+        }
+
+        button:hover {
+            filter: brightness(0.8);
+        }
+
+        #submit {
+            background: green;
+        }
+    </style>
+</head>
+
+<body>
+    <h1>Welcome to Vesktop</h1>
+    <p>Let's customise your experience!</p>
+
+    <form>
+        <label>
+            <h2>Discord Branch</h2>
+            <select name="discordBranch">
+                <option value="stable">stable</option>
+                <option value="canary">canary</option>
+                <option value="ptb">ptb</option>
+            </select>
+        </label>
+
+        <label>
+            <div>
+                <h2>Start with System</h2>
+                <span>Automatically open Vesktop when your computer starts</span>
+            </div>
+            <input type="checkbox" name="autoStart" />
+        </label>
+
+        <label>
+            <div>
+                <h2>Rich Presence</h2>
+                <span
+                    >Enable Rich presence (game activity) via
+                    <a href="https://github.com/OpenAsar/arrpc" target="_blank">arRPC</a></span
+                >
+            </div>
+            <input type="checkbox" name="richPresence" checked />
+        </label>
+
+        <label>
+            <div>
+                <h2>Import Settings</h2>
+                <span>Import Settings from existing Vencord install (if found)</span>
+            </div>
+            <input type="checkbox" name="importSettings" checked />
+        </label>
+
+        <label>
+            <div>
+                <h2>Minimise to Tray</h2>
+                <span>Minimise to Tray when closing</span>
+            </div>
+            <input type="checkbox" name="minimizeToTray" checked />
+        </label>
+    </form>
+    <div id="buttons">
+        <button id="cancel">Quit</button>
+        <button id="submit">Submit</button>
+    </div>
+</body>
+
+<script>
+    cancel.onclick = () => console.info("cancel");
+    submit.onclick = e => {
+        const form = document.querySelector("form");
+        const formData = new FormData(form);
+        const data = Object.fromEntries(formData.entries());
+        console.info("form:" + JSON.stringify(data));
+        e.preventDefault();
+    };
+</script>
--- a/static/views/splash.html
+++ b/static/views/splash.html
@@ -0,0 +1,41 @@
+<head>
+    <link rel="stylesheet" href="./style.css" type="text/css" />
+
+    <style>
+        * {
+            user-select: none;
+        }
+
+        .wrapper {
+            box-sizing: border-box;
+            height: 100%;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            border-radius: 8px;
+            border: 1px solid var(--fg-semi-trans);
+        }
+
+        p {
+            text-align: center;
+        }
+
+        img {
+            width: 6em;
+            height: 6em;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="wrapper">
+        <img
+            draggable="false"
+            src="../shiggy.gif"
+            alt="shiggy"
+            role="presentation"
+        />
+        <p>Loading Vesktop...</p>
+    </div>
+</body>
--- a/static/views/style.css
+++ b/static/views/style.css
@@ -0,0 +1,30 @@
+:root {
+    --bg: white;
+    --fg: black;
+    --fg-secondary: #313338;
+    --fg-semi-trans: rgb(0 0 0 / 0.2);
+    --link: #006ce7;
+}
+
+@media (prefers-color-scheme: dark) {
+    :root {
+        --bg: hsl(223 6.7% 20.6%);
+        --fg: white;
+        --fg-secondary: #b5bac1;
+        --fg-semi-trans: rgb(255 255 255 / 0.2);
+        --link: #00a8fc;
+    }
+}
+
+body {
+    font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell,
+        "Open Sans", "Helvetica Neue", sans-serif;
+    margin: 0;
+    padding: 0;
+    background: var(--bg);
+    color: var(--fg);
+}
+
+a {
+    color: var(--link);
+}
--- a/static/views/updater.html
+++ b/static/views/updater.html
@@ -0,0 +1,123 @@
+<head>
+    <link rel="stylesheet" href="./style.css" type="text/css" />
+
+    <style>
+        .wrapper {
+            display: flex;
+            flex-direction: column;
+            justify-content: space-between;
+            box-sizing: border-box;
+            min-height: 100%;
+            padding: 1em;
+        }
+
+        h1 {
+            text-align: center;
+        }
+
+        .buttons {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 0.5em;
+            margin-top: 0.25em;
+        }
+
+        button {
+            cursor: pointer;
+            padding: 0.5em;
+            color: var(--fg);
+            border: none;
+            border-radius: 3px;
+            font-weight: bold;
+            transition: filter 0.2 ease-in-out;
+        }
+
+        button:hover,
+        button:active {
+            filter: brightness(0.9);
+        }
+
+        .green {
+            background-color: #248046;
+        }
+
+        .red {
+            background-color: #ed4245;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="wrapper">
+        <section>
+            <h1>Update Available</h1>
+            <p>There's a new update for Vesktop! Update now to get new fixes and features!</p>
+            <p>
+                Current: <span id="current"></span>
+                <br />
+                Latest: <span id="latest"></span>
+            </p>
+
+            <h2>Changelog</h2>
+            <p id="changelog">Loading...</p>
+        </section>
+
+        <section>
+            <label id="disable-remind">
+                <input type="checkbox" />
+                <span>Do not remind again for </span>
+            </label>
+
+            <div class="buttons">
+                <button name="download" class="green">Download Update</button>
+                <button name="close" class="red">Close</button>
+            </div>
+        </section>
+    </div>
+</body>
+
+<script type="module">
+    const data = await Updater.getData();
+    document.getElementById("current").textContent = data.currentVersion;
+    document.getElementById("latest").textContent = data.latestVersion;
+
+    document.querySelector("#disable-remind > span").textContent += data.latestVersion;
+
+    function checkDisableRemind() {
+        const checkbox = document.querySelector("#disable-remind > input");
+        if (checkbox.checked) {
+            Updater.ignore();
+        }
+    }
+
+    const onClicks = {
+        download() {
+            checkDisableRemind();
+            Updater.download();
+        },
+        close() {
+            checkDisableRemind();
+            Updater.close();
+        }
+    };
+
+    for (const name in onClicks) {
+        document.querySelectorAll(`button[name="${name}"]`).forEach(button => {
+            button.addEventListener("click", onClicks[name]);
+        });
+    }
+</script>
+
+<script type="module">
+    import { micromark } from "https://esm.sh/micromark@3?bundle";
+    import { gfm, gfmHtml } from "https://esm.sh/micromark-extension-gfm@2?bundle";
+
+    const changelog = (await Updater.getData()).release.body;
+    if (changelog)
+        document.getElementById("changelog").innerHTML = micromark(changelog, {
+            extensions: [gfm()],
+            htmlExtensions: [gfmHtml()]
+        })
+            .replace(/h1>/g, "h3>")
+            .replace(/<a /g, '<a target="_blank" ');
+</script>
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -10,7 +10,12 @@
        "target": "ESNEXT",
        "jsx": "preserve",

-        "baseUrl": "./src/"
+        // we have duplicate electron types but it's w/e
+        "skipLibCheck": true,
+
+        "baseUrl": "./src/",
+
+        "typeRoots": ["./node_modules/@types", "./node_modules/@vencord"]
    },
    "include": ["src/**/*"]
 }
Author	SHA1	Message	Date
AAGaming	b24535483e	proper fix for disabling sandbox on steamos (#206 ) Co-authored-by: Vendicated <vendicated@riseup.net>	2023-11-01 01:50:18 +00:00
Vendicated	9521c287b6	remove electron-builder-sandbox-fix	2023-11-01 00:13:28 +01:00
Vendicated	55b9edec39	Bump to v0.4.3	2023-10-31 23:18:24 +01:00
AAGaming	1e9c70eed9	SteamOS: fixes & official controller layout (#194 )	2023-10-31 22:14:30 +01:00
Mars	3262e083fa	fix positioning of traffic lights on darwin (#185 ) Co-authored-by: V <vendicated@riseup.net>	2023-10-30 17:35:24 +00:00
Vendicated	ec1c719553	Bump venmic, improves support for older distros	2023-10-30 18:25:05 +01:00
Vendicated	cc62903b9c	bump to v0.4.2	2023-10-27 00:43:02 +02:00
Vendicated	b17370cc7b	add arm64 venmic binary	2023-10-27 00:42:50 +02:00
Vendicated	886d02f7c3	screenaudio: show better error if glibcxx too old	2023-10-27 00:27:35 +02:00
Nico	0cad71f6ae	fix: adjust hiding download button to new discord update (#176 )	2023-10-26 23:23:31 +02:00
Vendicated	b5eac15b42	Use correct OS in U-Agent ~ ~should fix captchas	2023-10-26 22:07:35 +02:00
rini	19c3112d52	fix spellcheck patch (#169 )	2023-10-25 20:57:08 +02:00
Vendicated	1c308d0e2c	Bump to v0.4.1	2023-10-25 00:32:06 +02:00
Vendicated	7f6db5eeda	Linux ScreenAudio: Remove Duplicates	2023-10-25 00:31:53 +02:00
Vendicated	10b38e5b41	make updater window close button close proper window	2023-10-25 00:30:42 +02:00
wearr	28282d1d76	Use local shiggy gif for splash (#157 ) Co-authored-by: wearrrrr <contact@wearr.dev> Co-authored-by: V <vendicated@riseup.net>	2023-10-25 00:25:17 +02:00
MiMillieuh	e1512b72f4	Fix : VM class for AppImage has broken Dekstop integrations (#160 )	2023-10-25 00:24:49 +02:00
AAGaming	46a2314173	fix turnary soup in main window options (#164 )	2023-10-25 00:24:37 +02:00
Vendicated	e6dc026708	Fix for latest canary	2023-10-24 23:12:22 +02:00
Lewis Crichton	cac307d1fc	ci: pin wgr to new version (#163 )	2023-10-23 17:44:54 +00:00
Ryan Cao	4b8f374856	feat: allow disabling updates check (#155 ) Co-authored-by: V <vendicated@riseup.net>	2023-10-22 17:10:25 +02:00
Jack	e6cc11fc0e	Build arm64 Linux packages (#151 )	2023-10-22 16:53:58 +02:00
Vendicated	43ca479fc8	bump to v0.4.0	2023-10-21 22:27:50 +02:00
Vendicated	7b0f64a9fc	remove legacy vencorddesktop aliases	2023-10-21 22:25:16 +02:00
V	573a953a2f	add linux audio screensharing (#130 ) Co-authored-by: V <vendicated@riseup.net> Co-authored-by: kaitlynkitty <87152313+kaitlynkittyy@users.noreply.github.com> Co-authored-by: Curve <fynnbwdt@gmail.com>	2023-10-21 22:15:55 +02:00
Ryan Cao	841cdcf672	feat: add splash window theming (#52 ) Co-authored-by: V <vendicated@riseup.net>	2023-10-14 03:04:44 +00:00
Vendicated	0d93e08e99	arrpc: migrate from websocket + plugin to electron ipc	2023-10-13 04:02:10 +02:00
Tornike Khintibidze	c445c6194f	MacOs: properly request microphone and camera permission (#121 ) Co-authored-by: V <vendicated@riseup.net>	2023-10-12 04:24:16 +02:00
Nick	e29d293855	README: hyperlink Vencord (#143 )	2023-10-11 17:24:39 +02:00
Vendicated	e13a4eacb1	bump deps	2023-10-11 17:21:32 +02:00
Vendicated	c070761f9d	Bump electron to v27	2023-10-11 17:19:45 +02:00
Lewis Crichton	ae86c28247	ci: force fork user to be bot account (#141 )	2023-10-07 16:19:42 +00:00
Lewis Crichton	9c95956c96	ci: allow manual submissions (#140 )	2023-10-07 18:10:07 +02:00
Vendicated	45f56c63a0	bump to v0.3.3	2023-09-30 22:45:22 +02:00
Tornike Khintibidze	89af4316d3	Optimize the menu bar for macOS (#120 ) Co-authored-by: V <vendicated@riseup.net>	2023-09-30 20:43:27 +00:00
Cynthia Foxwell	a9bfb857ae	Bump Electron to 25.8.4 for CVE-2023-5217 (#134 )	2023-09-30 19:38:32 +00:00
Vendicated	b9e411ac90	fix deb/rpm icon	2023-09-28 02:31:42 +02:00
Zyrouge	670de01938	fix: appimage not relaunching (#128 )	2023-09-27 04:52:00 +02:00
Lewis Crichton	ef064eba3d	ci: switch to vedantmgoyal2009/winget-releaser (#103 ) Co-authored-by: V <vendicated@riseup.net>	2023-09-26 00:00:17 +02:00
V	d5f63da939	bump to v0.3.2	2023-09-25 22:11:53 +02:00
Pierre	2aadc61af9	Downgrade electron to v25.8.2 (#126 )	2023-09-25 22:09:46 +02:00
Zyrouge	061fec44af	fix icon missing in some windows (#124 ) Co-authored-by: V <vendicated@riseup.net>	2023-09-25 01:19:54 +00:00
V	b876f450c3	bump arrpc	2023-09-25 03:17:50 +02:00
V	5f5febda9d	bump electron for important security fixes	2023-09-25 03:12:51 +02:00
Lewis Crichton	94ba59afb5	fix: add correct WMClass to desktop file (#108 ) resolves #96	2023-08-31 22:52:12 +02:00
V	566737017c	ci: publish as draft	2023-08-27 22:40:37 +02:00
Lewis Crichton	196ee4e42c	ci: winget (#101 )	2023-08-27 22:27:23 +02:00
V	9bb02f8581	security: make ipc only allow discord origins	2023-08-25 15:32:06 +02:00
V	c76d7195a5	Bump to 0.3.0	2023-08-16 02:05:17 +02:00
V	50a103710d	Add Vesktop section to Settings customSections	2023-08-16 02:02:23 +02:00
DaBluLite	e6e66e775c	Fix platformClass: change "platform-windows" to "platform-win" (#94 )	2023-08-14 13:55:47 +00:00
V	a5ec031a2f	Fix windows titlebar on canary	2023-08-12 04:01:10 +02:00
V	4dceadbbd2	Bump to 0.2.9 (for real this time)	2023-08-12 03:15:37 +02:00
V	6ee920ff2c	Show error toast when selecting invalid venchord dir	2023-08-12 03:15:21 +02:00
V	28ad4a6f73	Improve valid vencord install checks	2023-08-12 03:13:07 +02:00
V	c5ac3e64a6	Bump to 0.2.9	2023-08-12 03:09:38 +02:00
Justice Almanzar	6dc26aea6a	vecord: download proper vesktop specific preload & renderer css (#90 ) Co-authored-by: V <vendicated@riseup.net>	2023-08-12 03:09:14 +02:00
Hugo C	9003b94f85	mac: fix dock notification badge (#88 )	2023-08-08 13:08:32 +02:00
V	f7b7931847	only pass partial info	2023-08-07 00:48:23 +02:00
V	b87bcaefe9	Wayland: Skip our screenshare screen picker	2023-08-07 00:39:38 +02:00
V	3108de7c79	Port Discord's windows title bar (#86 )	2023-08-07 00:23:27 +02:00
Lewis Crichton	57006e7e52	feat: portable zip (#85 )	2023-08-06 02:05:48 +02:00
Nickyux	8f1ea1f440	Update Settings Text to Vesktop (#84 )	2023-08-05 17:18:12 +00:00
TymanWasTaken	26b6fb13d4	Update pnpm in package.json (#79 ) Co-authored-by: V <vendicated@riseup.net>	2023-08-04 20:36:28 +02:00
V	e1971f55a0	bump arrpc; fixes false positives	2023-08-04 20:21:49 +02:00
V	ba2618878e	add vencord themes watcher	2023-08-04 19:39:33 +02:00
V	87595deae7	Fix static title	2023-08-02 23:59:02 +02:00
V	6ab7030fdf	Bump to v0.2.8	2023-08-02 23:26:12 +02:00
V	5ba84e8a0d	but here's the bumper	2023-08-02 23:26:00 +02:00
V	61f9559984	Add Enable Menu setting	2023-07-28 21:54:17 +02:00
V	5fa9264bdb	mac: Hide tray related settings	2023-07-28 21:45:22 +02:00
V	c9f0920f71	Bump arRPC	2023-07-28 21:39:50 +02:00
V	f502d04b5f	Bump dependencies	2023-07-28 21:38:17 +02:00
Ryan Cao	08090e3764	feat: use standardized icon for macOS (#48 ) Co-authored-by: V <vendicated@riseup.net>	2023-07-27 01:03:29 +00:00
Hugo C	a95f7f8fbd	Remove macOS tray icon (#68 ) Co-authored-by: V <vendicated@riseup.net>	2023-07-27 00:20:15 +00:00
Ryan Cao	9d62cc9437	fix: macOS updater URL for different architectures (#69 ) Co-authored-by: V <vendicated@riseup.net>	2023-07-27 02:16:17 +02:00
V	2b4f7a07d2	Fix tray logic	2023-07-27 00:46:25 +02:00
V	be9642eff1	Bump to v0.2.7	2023-07-26 02:28:23 +02:00
Ryan Cao	d884b7d3d6	feat: add "Reset Vesktop" option to menu & tray (#53 ) Co-authored-by: V <vendicated@riseup.net>	2023-07-14 00:14:48 +00:00
Ryan Cao	6d35be79b8	feat: use inset title bar style on macOS (#47 ) Co-authored-by: V <vendicated@riseup.net>	2023-07-14 00:07:48 +00:00
Ryan Cao	70ca06eb16	fix: remove duplicate quit items on macOS (#49 ) Co-authored-by: V <vendicated@riseup.net>	2023-07-13 17:07:19 +00:00
V	210ddbae06	Rename to Vesktop (#57 )	2023-07-13 19:03:13 +02:00
V	3ee57831b9	Fix maximise button being wrongly disabled	2023-07-12 18:56:50 +02:00
Ryan Cao	72f83c3ac4	feat: add hide menu bar items on macOS (#50 ) Co-authored-by: V <vendicated@riseup.net>	2023-07-11 21:35:15 +02:00
Ryan Cao	13d87dc85e	fix: improve app hiding functionality (#51 )	2023-07-11 20:57:10 +02:00
Flag	0415cb77f7	feat: implement transparency for Windows (#46 )	2023-07-11 20:45:30 +02:00
V	b4da701080	Bump to 0.2.6	2023-07-05 00:49:43 +02:00
V	ed2361ff22	Don't show Menubar on alt press Closes #45	2023-07-03 22:25:11 +02:00
V	c587e93c56	oop oop	2023-07-03 22:22:35 +02:00
V	6ba0896a6e	Implement Screenshare Quality & fps settings	2023-07-03 22:12:26 +02:00
V	843b57e03e	Support invite modal launch from web	2023-06-30 18:57:28 +02:00
V	49fb4c68b6	Updater Popup: Add Changelog; Make about page prettier	2023-06-26 01:42:51 +02:00
V	477ecbb4ba	Cleanup	2023-06-26 00:41:52 +02:00
V	4abce9d084	Fix some Context Menus being broken by regression	2023-06-26 00:05:08 +02:00
V	7f54858b27	Add SpellCheck toggle in textarea context menu	2023-06-25 16:48:46 +02:00
V	be176fab71	Update README.md (#42 )	2023-06-25 04:55:06 +02:00
V	e60f04bb79	Fix DevTools context menu	2023-06-25 04:20:26 +02:00
V	17f1c4ff6f	Bump to v0.2.4	2023-06-25 03:45:44 +02:00
V	a7ded71404	Add SpellCheck suggestions	2023-06-25 03:44:19 +02:00
V	31799ccfb0	Add Notification badge	2023-06-23 17:20:54 +02:00
V	dde696627e	Bump to v0.2.3	2023-06-23 16:04:09 +02:00
V	50b2e864c2	Update UserAgents	2023-06-23 16:03:31 +02:00
V	dfa007669b	arrpc: Install from GitHub instead of npm	2023-06-23 16:01:50 +02:00
V	4b27c67e83	Bump electron from v23 to v25	2023-06-23 15:56:26 +02:00
V	f58ed485a9	Improve defaults, Add Rich Presence to first launch confi	2023-06-22 15:55:04 +02:00
V	c31eb8154b	Bump to v0.2.2	2023-06-21 20:53:28 +02:00
V	253277984b	Add ScreenSharing (#14 )	2023-06-21 20:52:56 +02:00
V	23c0647e6c	Fix ENOENT on first install	2023-06-21 17:24:50 +02:00
V	fd45068a46	autoStart: respect XDG_CONFIG_HOME	2023-06-21 17:09:04 +02:00
V	9f9f665ede	blehhhhh	2023-06-21 16:53:04 +02:00
V	fd0055032f	Add AutoStart to first launch tour	2023-06-21 16:52:28 +02:00
V	a993d34c9d	autostart: improve typing	2023-06-21 16:15:57 +02:00
V	f232defd1c	Add start with system option	2023-06-21 16:13:20 +02:00
V	887f11ab37	About page: Add Acknowledgements	2023-06-21 15:06:06 +02:00
V	4c34f10bb2	bump to v.0.2.1	2023-06-21 14:47:25 +02:00
V	684f3330e9	Fix updater file logic	2023-06-21 14:46:40 +02:00
V	178bb0c012	Add first launch tour (#38 )	2023-06-21 14:39:41 +02:00
V	39cc30de53	Add arRPC integration	2023-06-09 22:47:59 +02:00
Priultimus	aae4223294	Add MacOs arm64 build (#37 )	2023-05-24 03:02:30 +02:00
V	bddfa60f19	Update README.md	2023-05-05 01:30:11 +02:00
V	58b10cfcfe	Update README.md	2023-05-05 01:29:24 +02:00
Vendicated	36a751bb7b	v0.2.0	2023-05-03 04:14:03 +02:00
Vendicated	6a67f07a9e	Add portable target	2023-05-03 04:13:43 +02:00
V	c43871950c	Update README.md	2023-04-28 02:38:59 +02:00
Vendicated	fe70701de8	Fix zoom & about menu items; add version to about page	2023-04-27 02:23:17 +02:00
Vendicated	80f5735d04	Bump to v0.1.9	2023-04-27 01:26:57 +02:00
Vendicated	3305900cb8	Do not register as media service; Fix autoplay	2023-04-27 01:19:58 +02:00
Nick	c495e71f35	Static title (#17 )	2023-04-20 02:26:56 +00:00
Vendicated	4721c46d8c	Fix lint	2023-04-19 23:15:07 +02:00
Vendicated	0aaddf24c6	Migrate to @vencord/types package	2023-04-19 22:47:47 +02:00
Vendicated	427fde27ad	Remove AUR ci stuff	2023-04-18 01:08:15 +02:00
Vendicated	a12ba017bc	bump to 0.1.8	2023-04-15 20:24:09 +02:00
Vendicated	7a2161d746	Make IS_DEV force new instance	2023-04-15 20:23:47 +02:00
Vendicated	d0e7a319d6	Spoof UserAgent as browser. Fixes VCs?????	2023-04-15 20:13:18 +02:00
Vendicated	4afafa5038	bump	2023-04-15 12:38:17 +02:00
Ryan Cao	583680d311	feat: reuse built-in menus in system menubar (#12 ) * fix: add edit menu on macOS to allow clipboard actions * feat: reuse more built-in menus * re-add zoom shortcut fix --------- Co-authored-by: V <vendicated@riseup.net>	2023-04-15 10:37:52 +00:00
Vendicated	70dd38f79d	make spellcheck use all system locales	2023-04-14 04:05:56 +02:00
Sofia Lima	9120d05efc	fix makepkg in AUR workflow again (#11 )	2023-04-11 05:43:12 +02:00
Vendicated	3a820b458f	Fix ssh shenanigans	2023-04-11 02:12:10 +02:00
Sofia Lima	47f3b7fc89	fix AUR workflow (#10 )	2023-04-11 01:44:15 +02:00
Vendicated	838a3c78dd	Bump to 0.1.6	2023-04-10 22:54:09 +02:00
V	8d51cd5029	Add basic update notifications (#9 )	2023-04-10 22:53:44 +02:00
Vendicated	bfb9af05b0	Fix Settings not persisting, ooop	2023-04-10 22:30:39 +02:00
Vendicated	897df3a5d4	Add support for (optional) GITHUB_TOKEN env variable	2023-04-10 22:05:21 +02:00
Vendicated	d1296d1708	Windows: Fix taskbar icon getting removed on update	2023-04-10 21:37:14 +02:00
Vendicated	c5165afe7f	Unexplode release workflow	2023-04-10 19:38:32 +02:00
Vendicated	e16cdcf387	Bump to 0.1.5	2023-04-10 19:27:14 +02:00
Vendicated	1c2ed4679d	Fix custom vencord location	2023-04-10 19:26:59 +02:00
Ryan Cao	af42af070e	feat: implement translucency for macOS (#4 ) Co-authored-by: Vendicated <vendicated@riseup.net>	2023-04-10 19:21:45 +02:00
Vendicated	07d647ba2e	Fix outdated code	2023-04-10 19:20:16 +02:00
Vendicated	90b8c5fdfe	lint	2023-04-10 19:18:00 +02:00
Vendicated	c0598821ee	Add test workflow	2023-04-10 19:17:01 +02:00
Kode	de3aae1d95	Tray: Option to hide (#7 ) Co-authored-by: V <vendicated@riseup.net>	2023-04-10 19:12:58 +02:00
Vendicated	d1acb0490b	small fix	2023-04-10 03:26:55 +02:00
Vendicated	60759c142e	Increase window size on enable min size	2023-04-10 01:55:48 +02:00
Vendicated	0c77dbec92	Improve SettingsStore, add disableMinSize listener	2023-04-10 01:43:47 +02:00
Vendicated	edfeca15ce	add some jsdoc	2023-04-10 01:16:44 +02:00
Vendicated	c2eaa9d35a	Rewrite settings proxy to proper store	2023-04-10 01:04:41 +02:00
Vendicated	ddebb6563a	apply lint	2023-04-09 22:55:12 +02:00
Vendicated	df53ea549a	Add eslint config	2023-04-09 22:55:12 +02:00
Vendicated	a4954570b6	smaller version	2023-04-09 22:31:17 +02:00
Vendicated	ca376d35ab	Important splash screen fix	2023-04-09 22:30:34 +02:00
Sofia Lima	db76f111c8	add workflow for updating AUR package (#6 )	2023-04-09 21:36:05 +02:00
Vendicated	5efbbe2106	Improve settings texts	2023-04-09 06:05:52 +02:00
Vendicated	c29dd6d2d7	Add option to not minimize to tray	2023-04-09 05:57:45 +02:00
Vendicated	94b80ebe75	Fix comment location	2023-04-09 05:26:50 +02:00
Vendicated	bba8899f67	Implement frameless & windows ctrl q settings	2023-04-09 05:25:45 +02:00
Vendicated	ba0e8fedd0	Add minimum window height & width	2023-04-09 05:04:58 +02:00
V	27b6264c79	Update README.md	2023-04-09 04:35:27 +02:00
V	81929f1733	Add AUR package to README	2023-04-09 04:35:04 +02:00
Vendicated	d7e2dd0593	Remove pacman target its kinda scam	2023-04-09 04:23:52 +02:00
Vendicated	a807ae85fc	bump!	2023-04-09 04:11:22 +02:00
Vendicated	cb2fb648b6	Fix file downloader	2023-04-09 03:10:24 +02:00
Vendicated	e265e70fb9	fixes	2023-04-09 03:06:19 +02:00
Vendicated	805b6fbcc4	Add ability to load Vencord from custom location (dev install)	2023-04-09 02:26:31 +02:00
Vendicated	591d380160	Turn IpcEvents into a const enum	2023-04-09 01:22:31 +02:00
Vendicated	8f19d41d4c	Not infuriating at all	2023-04-09 01:20:35 +02:00
Vendicated	b4a2c41e74	VencordDesktop -> VencordDesktopNative; add VencordDesktop global	2023-04-09 01:20:00 +02:00
Vendicated	7e0532444d	Initial Settings UI work	2023-04-09 00:49:47 +02:00
Vendicated	8b68eef9a7	linux: Add .desktop file	2023-04-06 17:05:36 +02:00
Nick	e3f973ff68	chore: add missing homepage url (#3 ) * Update package.json * Update package.json	2023-04-06 06:32:19 +02:00