Merge branch 'main' into dependabot/nuget/Magick.NET-Q8-AnyCPU-14.0.0

Added a command line tool for user management (#420 )
The CLI tool can be started from the root of the /App directory in the container with the command: `./gaseous-cli` Running without arguments presents the following help screen: ``` Gaseous CLI - A tool for managing the Gaseous Server Usage: gaseous-cli [command] [options] Commands: user [command] [options] - Manage users role [command] [options] - Manage roles help - Display this help message ```
2024-09-09 15:15:16 +10:00 · 2024-09-09 15:11:36 +10:00 · 2024-09-09 04:49:00 +00:00 · 2024-09-08 00:14:29 +10:00 · 2024-09-06 01:59:59 +10:00 · 2024-09-03 12:35:41 +10:00
200 changed files with 20754 additions and 9528 deletions
--- a/.devcontainer/.env
+++ b/.devcontainer/.env
@@ -1,4 +0,0 @@
-DATABASE_HOST=mariadb
-DATABASE_USER=root
-DATABASE_PASSWORD=gaseous
-DATABASE_DB=gaseous
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -2,5 +2,5 @@ FROM mcr.microsoft.com/devcontainers/dotnet:1-8.0-bookworm

 RUN apt-get update && apt-get install -y p7zip-full
 RUN mkdir -p /workspace/gaseous-server/wwwroot/emulators/EmulatorJS
-RUN wget https://cdn.emulatorjs.org/releases/4.0.11.7z
-RUN 7z x -y -o/workspace/gaseous-server/wwwroot/emulators/EmulatorJS 4.0.11.7z
+RUN wget https://cdn.emulatorjs.org/releases/4.0.12.7z
+RUN 7z x -y -o/workspace/gaseous-server/wwwroot/emulators/EmulatorJS 4.0.12.7z
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -36,7 +36,9 @@
 				"AndersEAndersen.html-class-suggestions",
 				"george-alisson.html-preview-vscode",
 				"ms-dotnettools.vscodeintellicode-csharp",
-				"Zignd.html-css-class-completion"
+				"Zignd.html-css-class-completion",
+				"PWABuilder.pwa-studio",
+				"ms-azuretools.vscode-docker"
 			]
 		}
 	}
--- a/.devcontainer/docker-compose.yml
+++ b/.devcontainer/docker-compose.yml
@@ -11,11 +11,13 @@ services:
      - dbhost=${DATABASE_HOST}
      - dbuser=${DATABASE_USER}
      - dbpass=${DATABASE_PASSWORD}
-      - igdbclientid=<clientid>
-      - igdbclientsecret=<clientsecret>
+      - igdbclientid=${IGDB_CLIENT_ID}
+      - igdbclientsecret=${IGDB_CLIENT_SECRET}
  mariadb:
    hostname: mariadb
    image: mariadb:latest
+    ports:
+      - 3306:3306
    environment:
      - MARIADB_ROOT_PASSWORD=${DATABASE_PASSWORD}
      - MARIADB_DATABASE=${DATABASE_DB}
--- a/.github/workflows/BuildDockerOnTag-Prerelease.yml
+++ b/.github/workflows/BuildDockerOnTag-Prerelease.yml
@@ -9,9 +9,14 @@ on:
 jobs:
  docker:
    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+      attestations: write
+      id-token: write
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
        with:
          submodules: 'true'
      - name: Install dotnet tool
@@ -21,18 +26,37 @@ jobs:
      - name: Sign in to Nuget
        run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
      - name: Login to Docker Hub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v4
+      - name: Login to GitHub Package Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push standard image
+        uses: docker/build-push-action@v6
        with:
          context: .
+          file: ./build/Dockerfile
          platforms: linux/amd64,linux/arm64
          push: true
-          tags: gaseousgames/gaseousserver:${{ github.ref_name}}
+          tags: |
+            gaseousgames/gaseousserver:${{ github.ref_name}}
+            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}
+      - name: Build and push image with embedded mariadb
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./build/Dockerfile-EmbeddedDB
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            gaseousgames/gaseousserver:${{ github.ref_name}}-embeddeddb
+            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}-embeddeddb
--- a/.github/workflows/BuildDockerOnTag-Release.yml
+++ b/.github/workflows/BuildDockerOnTag-Release.yml
@@ -8,9 +8,14 @@ on:
 jobs:
  docker:
    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+      attestations: write
+      id-token: write
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
        with:
          submodules: 'true'
      - name: Install dotnet tool
@@ -20,18 +25,39 @@ jobs:
      - name: Sign in to Nuget
        run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
      - name: Login to Docker Hub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v4
+      - name: Login to GitHub Package Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push standard image
+        uses: docker/build-push-action@v6
        with:
          context: .
+          file: ./build/Dockerfile
          platforms: linux/amd64,linux/arm64
          push: true
-          tags: gaseousgames/gaseousserver:latest,gaseousgames/gaseousserver:${{ github.ref_name}}
+          tags: |
+            gaseousgames/gaseousserver:latest
+            gaseousgames/gaseousserver:${{ github.ref_name}}
+            ghcr.io/gaseous-project/gaseousserver:latest
+            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}
+      - name: Build and push image with embedded mariadb
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./build/Dockerfile-EmbeddedDB
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            gaseousgames/gaseousserver:${{ github.ref_name}}-embeddeddb
+            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}-embeddeddb
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -1,85 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "main", "branch-v*.*.*" ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ "main" ]
-  schedule:
-    - cron: '21 11 * * 2'
-
-jobs:
-  analyze:
-    name: Analyze
-    # Runner size impacts CodeQL analysis time. To learn more, please see:
-    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
-    #   - https://gh.io/supported-runners-and-hardware-resources
-    #   - https://gh.io/using-larger-runners
-    # Consider using larger runners for possible analysis time improvements.
-    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'csharp', 'javascript' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby', 'swift' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-      
-    - name: Sign in to Nuget
-      run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
-        
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"
--- a/.gitignore
+++ b/.gitignore
@@ -404,4 +404,7 @@ ASALocalRun/
 # Local History for Visual Studio
 .localhistory/
 gaseous-server/.DS_Store
+gaseous-server/wwwroot/.DS_Store
 gaseous-server/wwwroot/emulators/EmulatorJS
+.devcontainer/.env
+.mono/
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -24,7 +24,8 @@
            },
            "sourceFileMap": {
                "/Views": "${workspaceFolder}/Views"
-            }
+            },
+            "enableStepFiltering": false
        },
        {
            "name": ".NET Core Attach",
--- a/28
+++ b/28
@@ -1,28 +0,0 @@
-FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
-ARG TARGETARCH
-ARG BUILDPLATFORM
-WORKDIR /App
-EXPOSE 80
-
-RUN echo "Target: $TARGETARCH"
-RUN echo "Build: $BUILDPLATFORM"
-
-# Copy everything
-COPY . ./
-# Restore as distinct layers
-RUN dotnet restore "gaseous-server/gaseous-server.csproj" -a $TARGETARCH
-# Build and publish a release
-RUN dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
-
-# download and unzip EmulatorJS from CDN
-RUN apt-get update && apt-get install -y p7zip-full
-RUN mkdir -p out/wwwroot/emulators/EmulatorJS
-RUN wget https://cdn.emulatorjs.org/releases/4.0.12.7z
-RUN 7z x -y -oout/wwwroot/emulators/EmulatorJS 4.0.12.7z
-
-# Build runtime image
-FROM mcr.microsoft.com/dotnet/aspnet:8.0
-ENV INDOCKER=1
-WORKDIR /App
-COPY --from=build-env /App/out .
-ENTRYPOINT ["dotnet", "gaseous-server.dll"]
--- a/Gaseous.sln
+++ b/Gaseous.sln
@@ -1,4 +1,4 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 25.0.1704.4
@@ -21,36 +21,30 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "screenshots", "screenshots"
 		screenshots\Game.png = screenshots\Game.png
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gaseous-cli", "gaseous-cli\gaseous-cli.csproj", "{419CC4E4-8932-4E4A-B027-5521AA0CBA85}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{08699C93-15CD-4E39-9053-D3C8056CE938}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{08699C93-15CD-4E39-9053-D3C8056CE938}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{08699C93-15CD-4E39-9053-D3C8056CE938}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{08699C93-15CD-4E39-9053-D3C8056CE938}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Release|Any CPU.Build.0 = Release|Any CPU
-		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {979BF092-AFBC-4F19-B55F-32E73959BD1A}
-	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{F1A847C7-57BC-4DA9-8F83-CD060A7F5122} = {17FA6F12-8532-420C-9489-CB8FDE42137C}
 	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {979BF092-AFBC-4F19-B55F-32E73959BD1A}
+	EndGlobalSection
 EndGlobal
--- a/147
+++ b/147
@@ -1,5 +1,5 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
@@ -7,17 +7,15 @@

                            Preamble

-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.

  The licenses for most software and other practical works are designed
 to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
+our General Public Licenses are intended to guarantee your freedom to
 share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
+software for all its users.

  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
@@ -26,44 +24,34 @@ them if you wish), that you receive source code or can get it if you
 want it, that you can change the software or use pieces of it in new
 free programs, and that you know you can do these things.

-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.

-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.

-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.

-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.

  The precise terms and conditions for copying, distribution and
 modification follow.
@@ -72,7 +60,7 @@ modification follow.

  0. Definitions.

-  "This License" refers to version 3 of the GNU General Public License.
+  "This License" refers to version 3 of the GNU Affero General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
 works, such as semiconductor masks.
@@ -549,35 +537,45 @@ to collect a royalty for further conveying from those to whom you convey
 the Program, the only way you could satisfy both those terms and this
 License would be to refrain entirely from conveying the Program.

-  13. Use with the GNU Affero General Public License.
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.

  Notwithstanding any other provision of this License, you have
 permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
+under version 3 of the GNU General Public License into a single
 combined work, and to convey the resulting work.  The terms of this
 License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.

  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
+Program specifies that a certain numbered version of the GNU Affero General
 Public License "or any later version" applies to it, you have the
 option of following the terms and conditions either of that numbered
 version or of any later version published by the Free Software
 Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
+GNU Affero General Public License, you may choose any version ever published
 by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
+versions of the GNU Affero General Public License can be used, that proxy's
 public statement of acceptance of a version permanently authorizes you
 to choose that version for the Program.

@@ -631,44 +629,33 @@ to attach them to the start of each source file to most effectively
 state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.

-    Gaseous
-    Copyright (C) 2023  Gaseous
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>

    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+    GNU Affero General Public License for more details.

-    You should have received a copy of the GNU General Public License
+    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

 Also add information on how to contact you by electronic and paper mail.

-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) 2023  Gaseous
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.

  You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
+For more information on this, and how to apply and follow the GNU AGPL, see
 <https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
--- a/README.MD
+++ b/README.MD
@@ -16,9 +16,9 @@ Version 1.7.0 and later contain user authentication, and can be exposed to the i
 While we do our best to stay on top of server security, if you expose the server to the internet **you do so at your own risk**.

 ## Screenshots
-![Library](./screenshots/Library.png)
-![Game](./screenshots/Game.png)
-![Emulator](./screenshots/Emulator.png)
+![Library](./gaseous-server/wwwroot/screenshots/Library.png)
+![Game](./gaseous-server/wwwroot/screenshots/Game.png)
+![Emulator](./gaseous-server/wwwroot/screenshots/Emulator.png)


 ## Requirements
--- a/build/Dockerfile
+++ b/build/Dockerfile
@@ -0,0 +1,73 @@
+FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
+ARG TARGETARCH
+ARG BUILDPLATFORM
+WORKDIR /App
+EXPOSE 80
+
+RUN echo "Target: $TARGETARCH"
+RUN echo "Build: $BUILDPLATFORM"
+
+# Copy everything
+COPY .. ./
+
+# Build Gaseous Web Server
+# Restore as distinct layers
+RUN dotnet restore "gaseous-server/gaseous-server.csproj" -a $TARGETARCH
+# Build and publish a release
+RUN dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
+
+# Build Gaseous CLI
+# Restore as distinct layers
+RUN dotnet restore "gaseous-cli/gaseous-cli.csproj" -a $TARGETARCH
+# Build and publish a release
+RUN dotnet publish "gaseous-cli/gaseous-cli.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
+
+# update apt-get
+RUN apt-get update
+
+# # download and unzip EmulatorJS from CDN
+RUN apt-get install -y p7zip-full
+RUN mkdir -p out/wwwroot/emulators/EmulatorJS
+RUN wget https://cdn.emulatorjs.org/releases/4.0.12.7z
+RUN 7z x -y -oout/wwwroot/emulators/EmulatorJS 4.0.12.7z
+
+# clean up apt-get
+RUN apt-get clean && rm -rf /var/lib/apt/lists
+
+# Build runtime image
+FROM mcr.microsoft.com/dotnet/aspnet:8.0
+ENV INDOCKER=1
+WORKDIR /App
+COPY --from=build-env /App/out .
+
+# variables
+ARG PUID=1000
+ARG PGID=1000
+ARG dbhost=localhost
+ARG dbuser=root
+ARG dbpass=gaseous
+
+ENV PUID=${PUID}
+ENV PGID=${PGID}
+ENV dbhost=${dbhost}
+ENV dbuser=${dbuser}
+ENV dbpass=${dbpass}
+
+# install supervisord
+RUN apt-get update && apt-get install -y supervisor
+COPY ../build/standard/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
+RUN mkdir -p /var/run/supervisord
+RUN mkdir -p /var/log/supervisord
+
+# clean up apt-get
+RUN apt-get clean && rm -rf /var/lib/apt/lists
+
+# copy entrypoint
+COPY ../build/standard/entrypoint.sh /usr/sbin/entrypoint.sh
+RUN chmod +x /usr/sbin/entrypoint.sh
+
+# volumes
+VOLUME /home/gaseous/.gaseous-server
+
+# start services
+ENTRYPOINT [ "/usr/sbin/entrypoint.sh" ]
--- a/build/Dockerfile-EmbeddedDB
+++ b/build/Dockerfile-EmbeddedDB
@@ -0,0 +1,79 @@
+FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
+ARG TARGETARCH
+ARG BUILDPLATFORM
+WORKDIR /App
+EXPOSE 80
+
+RUN echo "Target: $TARGETARCH"
+RUN echo "Build: $BUILDPLATFORM"
+
+# Copy everything
+COPY .. ./
+
+# Build Gaseous Web Server
+# Restore as distinct layers
+RUN dotnet restore "gaseous-server/gaseous-server.csproj" -a $TARGETARCH
+# Build and publish a release
+RUN dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
+
+# Build Gaseous CLI
+# Restore as distinct layers
+RUN dotnet restore "gaseous-cli/gaseous-cli.csproj" -a $TARGETARCH
+# Build and publish a release
+RUN dotnet publish "gaseous-cli/gaseous-cli.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
+
+# update apt-get
+RUN apt-get update
+
+# # download and unzip EmulatorJS from CDN
+RUN apt-get install -y p7zip-full
+RUN mkdir -p out/wwwroot/emulators/EmulatorJS
+RUN wget https://cdn.emulatorjs.org/releases/4.0.12.7z
+RUN 7z x -y -oout/wwwroot/emulators/EmulatorJS 4.0.12.7z
+
+# Build runtime image
+FROM mcr.microsoft.com/dotnet/aspnet:8.0
+ENV INDOCKER=1
+WORKDIR /App
+COPY --from=build-env /App/out .
+
+# variables
+ARG PUID=1000
+ARG PGID=1000
+ARG dbhost=localhost
+ARG dbuser=root
+ARG dbpass=gaseous
+ARG MARIADB_ROOT_PASSWORD=$dbpass
+
+ENV PUID=${PUID}
+ENV PGID=${PGID}
+ENV dbhost=${dbhost}
+ENV dbuser=${dbuser}
+ENV dbpass=${dbpass}
+ENV MARIADB_ROOT_PASSWORD=${dbpass}
+
+# install mariadb
+RUN DEBIAN_FRONTEND=noninteractive && \
+    apt-get update && apt-get install -y mariadb-server
+RUN mkdir -p /run/mysqld
+COPY ../build/embeddeddb/mariadb.sh /usr/sbin/start-mariadb.sh
+RUN chmod +x /usr/sbin/start-mariadb.sh
+
+# install supervisord
+RUN apt-get install -y supervisor
+COPY ../build/embeddeddb/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
+RUN mkdir -p /var/run/supervisord
+RUN mkdir -p /var/log/supervisord
+
+# clean up apt-get
+RUN apt-get clean && rm -rf /var/lib/apt/lists
+
+# copy entrypoint
+COPY ../build/embeddeddb/entrypoint.sh /usr/sbin/entrypoint.sh
+RUN chmod +x /usr/sbin/entrypoint.sh
+
+# volumes
+VOLUME /home/gaseous/.gaseous-server /var/lib/mysql
+
+# start services
+ENTRYPOINT [ "/usr/sbin/entrypoint.sh" ]
--- a/build/embeddeddb/entrypoint.sh
+++ b/build/embeddeddb/entrypoint.sh
@@ -0,0 +1,18 @@
+#!/bin/sh
+
+# create the user
+echo "Creating user gaseous with UID ${PUID} and GID ${PGID}"
+groupadd -g ${PGID} gaseous
+useradd -u ${PUID} -g ${PGID} -m gaseous -d /home/gaseous -G sudo 
+usermod -p "*" gaseous
+mkdir -p /home/gaseous/.gaseous-server
+chown -R ${PUID} /App /home/gaseous/.gaseous-server
+chgrp -R ${PGID} /App /home/gaseous/.gaseous-server
+
+# Set MariaDB permissions
+mkdir -p /var/lib/mysql /var/log/mariadb /run/mysqld
+chown -R ${PUID} /var/lib/mysql /var/log/mariadb /run/mysqld
+chgrp -R ${PGID} /var/lib/mysql /var/log/mariadb /run/mysqld
+
+# Start supervisord and services
+/usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf
--- a/build/embeddeddb/mariadb.sh
+++ b/build/embeddeddb/mariadb.sh
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# install the database
+echo "Installing MariaDB"
+/usr/bin/mariadb-install-db --datadir=/var/lib/mysql --user=gaseous
+
+# start the database server without network or grant tables
+echo "Starting MariaDB"
+/usr/sbin/mariadbd --datadir=/var/lib/mysql  --skip-grant-tables --skip-networking &
+
+# wait for the server to start
+sleep 5
+
+# change the root password
+echo "Setting MariaDB root password"
+mariadb -u root -e "FLUSH PRIVILEGES; ALTER USER 'root'@'localhost' IDENTIFIED BY '$MARIADB_ROOT_PASSWORD'; ALTER USER 'gaseous'@'localhost' IDENTIFIED BY '$MARIADB_ROOT_PASSWORD'; FLUSH PRIVILEGES; SHUTDOWN;"
+
+# stop the server
+sleep 5
+echo "Stopping MariaDB"
+killall mariadbd
+
+# start the server normally
+echo "Starting MariaDB"
+/usr/sbin/mariadbd --datadir=/var/lib/mysql --user=gaseous
--- a/build/embeddeddb/supervisord.conf
+++ b/build/embeddeddb/supervisord.conf
@@ -0,0 +1,37 @@
+[supervisord]
+user=root
+nodaemon=true
+logfile=/var/log/supervisord/supervisord.log
+logfile_maxbytes=50
+logfile_backups=5
+pidfile=/var/run/supervisord/supervisord.pid
+loglevel = info
+
+[unix_http_server]
+file=/var/run/supervisord/supervisor.sock
+chmod=0700
+
+[rpcinterface:supervisor]
+supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+[supervisorctl]
+serverurl=unix:///var/run/supervisord/supervisor.sock
+
+[program:mariadb]
+user=gaseous
+command=bash -c "/usr/sbin/start-mariadb.sh"
+autostart=true
+autorestart=true
+redirect_stderr=true
+stdout_logfile=/dev/fd/1
+stdout_logfile_maxbytes=0
+
+[program:gaseous-server]
+user=gaseous
+command=dotnet /App/gaseous-server.dll
+environment=HOME="/home/gaseous",USER="gaseous"
+autostart=true
+autorestart=true
+redirect_stderr=true
+stdout_logfile=/dev/fd/1
+stdout_logfile_maxbytes=0
--- a/build/standard/entrypoint.sh
+++ b/build/standard/entrypoint.sh
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+# create the user
+echo "Creating user gaseous with UID ${PUID} and GID ${PGID}"
+groupadd -g ${PGID} gaseous
+useradd -u ${PUID} -g ${PGID} -m gaseous -d /home/gaseous -G sudo 
+usermod -p "*" gaseous
+mkdir -p /home/gaseous/.gaseous-server
+chown -R ${PUID} /App /home/gaseous/.gaseous-server
+chgrp -R ${PGID} /App /home/gaseous/.gaseous-server
+
+# Start supervisord and services
+/usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf
--- a/build/standard/supervisord.conf
+++ b/build/standard/supervisord.conf
@@ -0,0 +1,28 @@
+[supervisord]
+user=root
+nodaemon=true
+logfile=/var/log/supervisord/supervisord.log
+logfile_maxbytes=50
+logfile_backups=5
+pidfile=/var/run/supervisord/supervisord.pid
+loglevel = info
+
+[unix_http_server]
+file=/var/run/supervisord/supervisor.sock
+chmod=0700
+
+[rpcinterface:supervisor]
+supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+[supervisorctl]
+serverurl=unix:///var/run/supervisord/supervisor.sock
+
+[program:gaseous-server]
+user=gaseous
+command=dotnet /App/gaseous-server.dll
+environment=HOME="/home/gaseous",USER="gaseous"
+autostart=true
+autorestart=true
+redirect_stderr=true
+stdout_logfile=/dev/fd/1
+stdout_logfile_maxbytes=0
--- a/docker-compose-build.yml
+++ b/docker-compose-build.yml
@@ -4,6 +4,7 @@ services:
    container_name: gaseous-server
    build:
      context: ./
+      dockerfile: ./build/Dockerfile
    restart: unless-stopped
    networks:
      - gaseous
@@ -12,7 +13,7 @@ services:
    ports:
      - 5198:80
    volumes:
-      - gs:/root/.gaseous-server
+      - gs:/home/gaseous/.gaseous-server
    environment:
      - TZ=Australia/Sydney
      - dbhost=gsdb
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -11,7 +11,7 @@ services:
    ports:
      - 5198:80
    volumes:
-      - gs:/root/.gaseous-server
+      - gs:/home/gaseous/.gaseous-server
    environment:
      - TZ=Australia/Sydney
      - dbhost=gsdb
--- a/gaseous-cli/Program.cs
+++ b/gaseous-cli/Program.cs
@@ -0,0 +1,354 @@
+using System;
+using Authentication;
+using gaseous_server.Classes;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+/* ------------------------------------------------- */
+/* This tool is a CLI tool that is used to manage    */
+/* the Gaseous Server.                               */
+/* Functions such as user management, and backups    */
+/* are available.                                    */
+/* ------------------------------------------------- */
+
+// load app settings
+Config.InitSettings();
+
+// set up database connection
+Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+
+// set up identity
+IServiceCollection services = new ServiceCollection();
+services.AddLogging();
+
+services.AddIdentity<ApplicationUser, ApplicationRole>(options =>
+        {
+            options.Password.RequireDigit = true;
+            options.Password.RequireLowercase = true;
+            options.Password.RequireNonAlphanumeric = false;
+            options.Password.RequireUppercase = true;
+            options.Password.RequiredLength = 10;
+            options.User.AllowedUserNameCharacters = null;
+            options.User.RequireUniqueEmail = true;
+            options.SignIn.RequireConfirmedPhoneNumber = false;
+            options.SignIn.RequireConfirmedEmail = false;
+            options.SignIn.RequireConfirmedAccount = false;
+        })
+    .AddUserStore<UserStore>()
+    .AddRoleStore<RoleStore>()
+    ;
+services.AddScoped<UserStore>();
+services.AddScoped<RoleStore>();
+
+services.AddTransient<IUserStore<ApplicationUser>, UserStore>();
+services.AddTransient<IRoleStore<ApplicationRole>, RoleStore>();
+var userManager = services.BuildServiceProvider().GetService<UserManager<ApplicationUser>>();
+
+// load the command line arguments
+string[] cmdArgs = Environment.GetCommandLineArgs();
+
+// check if the user has entered any arguments
+if (cmdArgs.Length == 1)
+{
+    // no arguments were entered
+    Console.WriteLine("Gaseous CLI - A tool for managing the Gaseous Server");
+    Console.WriteLine("Usage: gaseous-cli [command] [options]");
+    Console.WriteLine("Commands:");
+    Console.WriteLine("  user [command] [options] - Manage users");
+    Console.WriteLine("  role [command] [options] - Manage roles");
+    // Console.WriteLine("  backup [command] [options] - Manage backups");
+    // Console.WriteLine("  restore [command] [options] - Restore backups");
+    Console.WriteLine("  help - Display this help message");
+    return;
+}
+
+// check if the user has entered the help command
+if (cmdArgs[1] == "help")
+{
+    // display the help message
+    Console.WriteLine("Gaseous CLI - A tool for managing the Gaseous Server");
+    Console.WriteLine("Usage: gaseous-cli [command] [options]");
+    Console.WriteLine("Commands:");
+    Console.WriteLine("  user [command] [options] - Manage users");
+    Console.WriteLine("  role [command] [options] - Manage roles");
+    // Console.WriteLine("  backup [command] [options] - Manage backups");
+    // Console.WriteLine("  restore [command] [options] - Restore backups");
+    Console.WriteLine("  help - Display this help message");
+    return;
+}
+
+// check if the user has entered the user command
+if (cmdArgs[1] == "user")
+{
+    // check if the user has entered any arguments
+    if (cmdArgs.Length == 2)
+    {
+        // no arguments were entered
+        Console.WriteLine("User Management");
+        Console.WriteLine("Usage: gaseous-cli user [command] [options]");
+        Console.WriteLine("Commands:");
+        Console.WriteLine("  add [username] [password] - Add a new user");
+        Console.WriteLine("  delete [username] - Delete a user");
+        Console.WriteLine("  resetpassword [username] [password] - Reset a user's password");
+        Console.WriteLine("  list - List all users");
+        return;
+    }
+
+    // check if the user has entered the add command
+    if (cmdArgs[2] == "add")
+    {
+        // check if the user has entered the username and password
+        if (cmdArgs.Length < 5)
+        {
+            // the username and password were not entered
+            Console.WriteLine("Error: Please enter a username and password");
+            return;
+        }
+
+        // add a new user
+        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
+        if (userTable.GetUserByEmail(cmdArgs[3]) != null)
+        {
+            Console.WriteLine("Error: User already exists");
+            return;
+        }
+
+        // create the user object
+        ApplicationUser user = new ApplicationUser
+        {
+            Id = Guid.NewGuid().ToString(),
+            Email = cmdArgs[3],
+            NormalizedEmail = cmdArgs[3].ToUpper(),
+            EmailConfirmed = true,
+            UserName = cmdArgs[3],
+            NormalizedUserName = cmdArgs[3].ToUpper()
+        };
+
+        // create the password
+        PasswordHasher<ApplicationUser> passwordHasher = new PasswordHasher<ApplicationUser>();
+        user.PasswordHash = passwordHasher.HashPassword(user, cmdArgs[4]);
+
+        await userManager.CreateAsync(user);
+        await userManager.AddToRoleAsync(user, "Player");
+
+        Console.WriteLine("User created successfully with default role: Player");
+
+        return;
+    }
+
+    // check if the user has entered the delete command
+    if (cmdArgs[2] == "delete")
+    {
+        // check if the user has entered the username
+        if (cmdArgs.Length < 4)
+        {
+            // the username was not entered
+            Console.WriteLine("Error: Please enter a username");
+            return;
+        }
+
+        // delete the user
+        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
+        ApplicationUser user = userTable.GetUserByEmail(cmdArgs[3]);
+        if (user == null)
+        {
+            Console.WriteLine("Error: User not found");
+            return;
+        }
+
+        await userManager.DeleteAsync(user);
+
+        Console.WriteLine("User deleted successfully");
+
+        return;
+    }
+
+    // check if the user has entered the resetpassword command
+    if (cmdArgs[2] == "resetpassword")
+    {
+        // check if the user has entered the username and password
+        if (cmdArgs.Length < 5)
+        {
+            // the username and password were not entered
+            Console.WriteLine("Error: Please enter a username and password");
+            return;
+        }
+
+        // reset the user's password
+        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
+        ApplicationUser user = userTable.GetUserByEmail(cmdArgs[3]);
+        if (user == null)
+        {
+            Console.WriteLine("Error: User not found");
+            return;
+        }
+
+        // create the password
+        PasswordHasher<ApplicationUser> passwordHasher = new PasswordHasher<ApplicationUser>();
+        user.PasswordHash = passwordHasher.HashPassword(user, cmdArgs[4]);
+
+        await userManager.UpdateAsync(user);
+
+        Console.WriteLine("Password reset successfully");
+
+        return;
+    }
+
+    // check if the user has entered the list command
+    if (cmdArgs[2] == "list")
+    {
+        // list all users
+        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
+        var userList = userTable.GetUsers();
+        foreach (var user in userList)
+        {
+            var roles = await userManager.GetRolesAsync(user);
+            Console.WriteLine(user.Email + " - " + string.Join(", ", roles));
+        }
+        return;
+    }
+}
+
+// check if the user has entered the role command
+if (cmdArgs[1] == "role")
+{
+    // check if the user has entered any arguments
+    if (cmdArgs.Length == 2)
+    {
+        // no arguments were entered
+        Console.WriteLine("Role Management");
+        Console.WriteLine("Usage: gaseous-cli role [command] [options]");
+        Console.WriteLine("Commands:");
+        Console.WriteLine("  set [username] [role] - Set the role of a user");
+        Console.WriteLine("  list - List all roles");
+        return;
+    }
+
+    // check if the user has entered the role command
+    if (cmdArgs[2] == "set")
+    {
+        // check if the user has entered the username and role
+        if (cmdArgs.Length < 5)
+        {
+            // the username and role were not entered
+            Console.WriteLine("Error: Please enter a username and role");
+            return;
+        }
+
+        // set the role of the user
+        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
+        ApplicationUser user = userTable.GetUserByEmail(cmdArgs[3]);
+        if (user == null)
+        {
+            Console.WriteLine("Error: User not found");
+            return;
+        }
+
+        // remove all existing roles from user
+        var roles = await userManager.GetRolesAsync(user);
+        await userManager.RemoveFromRolesAsync(user, roles.ToArray());
+
+        // add the new role to the user
+        await userManager.AddToRoleAsync(user, cmdArgs[4]);
+
+        Console.WriteLine("Role set successfully");
+
+        return;
+    }
+
+    // check if the user has entered the list command
+    if (cmdArgs[2] == "list")
+    {
+        // list all roles
+        string[] roles = { "Player", "Gamer", "Admin" };
+        foreach (var role in roles)
+        {
+            Console.WriteLine(role);
+        }
+        return;
+    }
+}
+
+// // check if the user has entered the backup command
+// if (cmdArgs[1] == "backup")
+// {
+//     // check if the user has entered any arguments
+//     if (cmdArgs.Length == 2)
+//     {
+//         // no arguments were entered
+//         Console.WriteLine("Backup Management");
+//         Console.WriteLine("Usage: gaseous-cli backup [command] [options]");
+//         Console.WriteLine("Commands:");
+//         Console.WriteLine("  create - Create a backup");
+//         Console.WriteLine("  list - List all backups");
+//         Console.WriteLine("  remove [backup_id] - Remove a backup");
+//         return;
+//     }
+
+//     // check if the user has entered the create command
+//     if (cmdArgs[2] == "create")
+//     {
+//         // create a backup
+//         Backup.CreateBackup();
+//         return;
+//     }
+
+//     // check if the user has entered the list command
+//     if (cmdArgs[2] == "list")
+//     {
+//         // list all backups
+//         Backup.ListBackups();
+//         return;
+//     }
+
+//     // check if the user has entered the remove command
+//     if (cmdArgs[2] == "remove")
+//     {
+//         // check if the user has entered the backup id
+//         if (cmdArgs.Length < 4)
+//         {
+//             // the backup id was not entered
+//             Console.WriteLine("Error: Please enter a backup id");
+//             return;
+//         }
+
+//         // remove the backup
+//         Backup.RemoveBackup(cmdArgs[3]);
+//         return;
+//     }
+// }
+
+// // check if the user has entered the restore command
+// if (cmdArgs[1] == "restore")
+// {
+//     // check if the user has entered any arguments
+//     if (cmdArgs.Length == 2)
+//     {
+//         // no arguments were entered
+//         Console.WriteLine("Restore Management");
+//         Console.WriteLine("Usage: gaseous-cli restore [command] [options]");
+//         Console.WriteLine("Commands:");
+//         Console.WriteLine("  restore [backup_id] - Restore a backup");
+//         return;
+//     }
+
+//     // check if the user has entered the restore command
+//     if (cmdArgs[2] == "restore")
+//     {
+//         // check if the user has entered the backup id
+//         if (cmdArgs.Length < 4)
+//         {
+//             // the backup id was not entered
+//             Console.WriteLine("Error: Please enter a backup id");
+//             return;
+//         }
+
+//         // restore the backup
+//         Restore.RestoreBackup(cmdArgs[3]);
+//         return;
+//     }
+// }
+
+// the user entered an invalid command
+Console.WriteLine("Error: Invalid command");
--- a/gaseous-cli/gaseous-cli.csproj
+++ b/gaseous-cli/gaseous-cli.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>gaseous_cli</RootNamespace>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Debug\net8.0\gaseous-cli.xml</DocumentationFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Release\net8.0\gaseous-cli.xml</DocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="MySqlConnector" Version="2.3.7" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\gaseous-server\gaseous-server.csproj" />
+  </ItemGroup>
+</Project>
--- a/gaseous-server/.DS_Store
+++ b/gaseous-server/.DS_Store
--- a/gaseous-server/Classes/Auth/Classes/IdentityUser.cs
+++ b/gaseous-server/Classes/Auth/Classes/IdentityUser.cs
@@ -12,6 +12,6 @@ namespace Authentication
    {
        public SecurityProfileViewModel SecurityProfile { get; set; }
        public List<UserPreferenceViewModel> UserPreferences { get; set; }
-        public Guid Avatar { get; set; }
+        public Guid ProfileId { get; set; }
    }
 }
--- a/gaseous-server/Classes/Auth/Classes/RoleTable.cs
+++ b/gaseous-server/Classes/Auth/Classes/RoleTable.cs
@@ -104,7 +104,7 @@ namespace Authentication
            var roleName = GetRoleName(roleId);
            ApplicationRole? role = null;

-            if(roleName != null)
+            if (roleName != null)
            {
                role = new ApplicationRole();
                role.Id = roleId;
@@ -153,7 +153,7 @@ namespace Authentication
            string commandText = "Select Name from Roles";

            var rows = _database.ExecuteCMDDict(commandText);
-            foreach(Dictionary<string, object> row in rows)
+            foreach (Dictionary<string, object> row in rows)
            {
                ApplicationRole role = (ApplicationRole)Activator.CreateInstance(typeof(ApplicationRole));
                role.Id = (string)row["Id"];
--- a/gaseous-server/Classes/Auth/Classes/UserRoleTable.cs
+++ b/gaseous-server/Classes/Auth/Classes/UserRoleTable.cs
@@ -35,7 +35,7 @@ namespace Authentication
            parameters.Add("@userId", userId);

            var rows = _database.ExecuteCMD(commandText, parameters).Rows;
-            foreach(DataRow row in rows)
+            foreach (DataRow row in rows)
            {
                roles.Add((string)row["Name"]);
            }
--- a/gaseous-server/Classes/Auth/Classes/UserTable.cs
+++ b/gaseous-server/Classes/Auth/Classes/UserTable.cs
@@ -10,7 +10,7 @@ namespace Authentication
    /// Class that represents the Users table in the MySQL Database
    /// </summary>
    public class UserTable<TUser>
-        where TUser :ApplicationUser
+        where TUser : ApplicationUser
    {
        private Database _database;

@@ -75,7 +75,7 @@ namespace Authentication
        public TUser GetUserById(string userId)
        {
            TUser user = null;
-            string commandText = "Select * from Users LEFT JOIN (SELECT UserId, Id AS AvatarId FROM UserAvatars) UserAvatars ON Users.Id = UserAvatars.UserId where Id = @id";
+            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId where Id = @id";
            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@id", userId } };

            var rows = _database.ExecuteCMDDict(commandText, parameters);
@@ -89,7 +89,7 @@ namespace Authentication
                user.SecurityStamp = (string?)(string.IsNullOrEmpty((string?)row["SecurityStamp"]) ? null : row["SecurityStamp"]);
                user.ConcurrencyStamp = (string?)(string.IsNullOrEmpty((string?)row["ConcurrencyStamp"]) ? null : row["ConcurrencyStamp"]);
                user.Email = (string?)(string.IsNullOrEmpty((string?)row["Email"]) ? null : row["Email"]);
-                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true:false;
+                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true : false;
                user.PhoneNumber = (string?)(string.IsNullOrEmpty((string?)row["PhoneNumber"]) ? null : row["PhoneNumber"]);
                user.PhoneNumberConfirmed = row["PhoneNumberConfirmed"] == "1" ? true : false;
                user.NormalizedEmail = (string?)(string.IsNullOrEmpty((string?)row["NormalizedEmail"]) ? null : row["NormalizedEmail"]);
@@ -97,10 +97,10 @@ namespace Authentication
                user.LockoutEnabled = row["LockoutEnabled"] == "1" ? true : false;
                user.LockoutEnd = string.IsNullOrEmpty((string?)row["LockoutEnd"]) ? DateTime.Now : DateTime.Parse((string?)row["LockoutEnd"]);
                user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
-                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true:false;
+                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
                user.SecurityProfile = GetSecurityProfile(user);
                user.UserPreferences = GetPreferences(user);
-                user.Avatar = string.IsNullOrEmpty((string?)row["AvatarId"]) ? Guid.Empty : Guid.Parse((string?)row["AvatarId"]);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
            }

            return user;
@@ -114,11 +114,11 @@ namespace Authentication
        public List<TUser> GetUserByName(string normalizedUserName)
        {
            List<TUser> users = new List<TUser>();
-            string commandText = "Select * from Users LEFT JOIN (SELECT UserId, Id AS AvatarId FROM UserAvatars) UserAvatars ON Users.Id = UserAvatars.UserId where NormalizedEmail = @name";
+            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId where NormalizedEmail = @name";
            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@name", normalizedUserName } };

            var rows = _database.ExecuteCMDDict(commandText, parameters);
-            foreach(Dictionary<string, object> row in rows)
+            foreach (Dictionary<string, object> row in rows)
            {
                TUser user = (TUser)Activator.CreateInstance(typeof(TUser));
                user.Id = (string)row["Id"];
@@ -127,7 +127,7 @@ namespace Authentication
                user.SecurityStamp = (string?)(string.IsNullOrEmpty((string?)row["SecurityStamp"]) ? null : row["SecurityStamp"]);
                user.ConcurrencyStamp = (string?)(string.IsNullOrEmpty((string?)row["ConcurrencyStamp"]) ? null : row["ConcurrencyStamp"]);
                user.Email = (string?)(string.IsNullOrEmpty((string?)row["Email"]) ? null : row["Email"]);
-                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true:false;
+                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true : false;
                user.PhoneNumber = (string?)(string.IsNullOrEmpty((string?)row["PhoneNumber"]) ? null : row["PhoneNumber"]);
                user.PhoneNumberConfirmed = row["PhoneNumberConfirmed"] == "1" ? true : false;
                user.NormalizedEmail = (string?)(string.IsNullOrEmpty((string?)row["NormalizedEmail"]) ? null : row["NormalizedEmail"]);
@@ -135,10 +135,10 @@ namespace Authentication
                user.LockoutEnabled = row["LockoutEnabled"] == "1" ? true : false;
                user.LockoutEnd = string.IsNullOrEmpty((string?)row["LockoutEnd"]) ? DateTime.Now : DateTime.Parse((string?)row["LockoutEnd"]);
                user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
-                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true:false;
+                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
                user.SecurityProfile = GetSecurityProfile(user);
                user.UserPreferences = GetPreferences(user);
-                user.Avatar = string.IsNullOrEmpty((string?)row["AvatarId"]) ? Guid.Empty : Guid.Parse((string?)row["AvatarId"]);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
                users.Add(user);
            }

@@ -148,10 +148,10 @@ namespace Authentication
        public List<TUser> GetUsers()
        {
            List<TUser> users = new List<TUser>();
-            string commandText = "Select * from Users LEFT JOIN (SELECT UserId, Id AS AvatarId FROM UserAvatars) UserAvatars ON Users.Id = UserAvatars.UserId order by NormalizedUserName";
+            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId order by NormalizedUserName";

            var rows = _database.ExecuteCMDDict(commandText);
-            foreach(Dictionary<string, object> row in rows)
+            foreach (Dictionary<string, object> row in rows)
            {
                TUser user = (TUser)Activator.CreateInstance(typeof(TUser));
                user.Id = (string)row["Id"];
@@ -160,7 +160,7 @@ namespace Authentication
                user.SecurityStamp = (string?)(string.IsNullOrEmpty((string?)row["SecurityStamp"]) ? null : row["SecurityStamp"]);
                user.ConcurrencyStamp = (string?)(string.IsNullOrEmpty((string?)row["ConcurrencyStamp"]) ? null : row["ConcurrencyStamp"]);
                user.Email = (string?)(string.IsNullOrEmpty((string?)row["Email"]) ? null : row["Email"]);
-                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true:false;
+                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true : false;
                user.PhoneNumber = (string?)(string.IsNullOrEmpty((string?)row["PhoneNumber"]) ? null : row["PhoneNumber"]);
                user.PhoneNumberConfirmed = row["PhoneNumberConfirmed"] == "1" ? true : false;
                user.NormalizedEmail = (string?)(string.IsNullOrEmpty((string?)row["NormalizedEmail"]) ? null : row["NormalizedEmail"]);
@@ -168,10 +168,10 @@ namespace Authentication
                user.LockoutEnabled = row["LockoutEnabled"] == "1" ? true : false;
                user.LockoutEnd = string.IsNullOrEmpty((string?)row["LockoutEnd"]) ? DateTime.Now : DateTime.Parse((string?)row["LockoutEnd"]);
                user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
-                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true:false;
+                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
                user.SecurityProfile = GetSecurityProfile(user);
                user.UserPreferences = GetPreferences(user);
-                user.Avatar = string.IsNullOrEmpty((string?)row["AvatarId"]) ? Guid.Empty : Guid.Parse((string?)row["AvatarId"]);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
                users.Add(user);
            }

@@ -258,10 +258,11 @@ namespace Authentication
        /// <returns></returns>
        public int Insert(TUser user)
        {
-            string commandText = @"Insert into Users (UserName, Id, PasswordHash, SecurityStamp, ConcurrencyStamp, Email, EmailConfirmed, PhoneNumber, PhoneNumberConfirmed, NormalizedEmail, NormalizedUserName, AccessFailedCount, LockoutEnabled, LockoutEnd, TwoFactorEnabled) values (@name, @id, @pwdHash, @SecStamp, @concurrencystamp, @email ,@emailconfirmed ,@phonenumber, @phonenumberconfirmed, @normalizedemail, @normalizedusername, @accesscount, @lockoutenabled, @lockoutenddate, @twofactorenabled);";
+            string commandText = @"Insert into Users (UserName, Id, PasswordHash, SecurityStamp, ConcurrencyStamp, Email, EmailConfirmed, PhoneNumber, PhoneNumberConfirmed, NormalizedEmail, NormalizedUserName, AccessFailedCount, LockoutEnabled, LockoutEnd, TwoFactorEnabled) values (@name, @id, @pwdHash, @SecStamp, @concurrencystamp, @email ,@emailconfirmed ,@phonenumber, @phonenumberconfirmed, @normalizedemail, @normalizedusername, @accesscount, @lockoutenabled, @lockoutenddate, @twofactorenabled); Insert into UserProfiles (Id, UserId, DisplayName, Quip, UnstructuredData) values (@profileId, @id, @email, '', '{}');";
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            parameters.Add("@name", user.UserName);
            parameters.Add("@id", user.Id);
+            parameters.Add("@profileId", Guid.NewGuid());
            parameters.Add("@pwdHash", user.PasswordHash);
            parameters.Add("@SecStamp", user.SecurityStamp);
            parameters.Add("@concurrencystamp", user.ConcurrencyStamp);
@@ -292,7 +293,7 @@ namespace Authentication
        /// <returns></returns>
        private int Delete(string userId)
        {
-            string commandText = "Delete from Users where Id = @userId; Delete from User_Settings where Id = @userId; Delete from GameState where UserId = @userId;";
+            string commandText = "Delete from Users where Id = @userId; Delete from User_Settings where Id = @userId; Delete from UserProfiles where UserId = @userId; Delete from GameState where UserId = @userId;";
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            parameters.Add("@userId", userId);

--- a/gaseous-server/Classes/Auth/Models/ProfileViewModel.cs
+++ b/gaseous-server/Classes/Auth/Models/ProfileViewModel.cs
@@ -8,8 +8,9 @@ namespace Authentication
        public List<String> Roles { get; set; }
        public SecurityProfileViewModel SecurityProfile { get; set; }
        public List<UserPreferenceViewModel> UserPreferences { get; set; }
-        public Guid Avatar { get; set; }
-        public string HighestRole {
+        public Guid ProfileId { get; set; }
+        public string HighestRole
+        {
            get
            {
                string _highestRole = "";
--- a/gaseous-server/Classes/Auth/Models/UserViewModel.cs
+++ b/gaseous-server/Classes/Auth/Models/UserViewModel.cs
@@ -8,38 +8,46 @@ namespace Authentication
        public DateTimeOffset? LockoutEnd { get; set; }
        public List<string> Roles { get; set; }
        public SecurityProfileViewModel SecurityProfile { get; set; }
-        public Guid Avatar { get; set; }
-        public string HighestRole {
+        public Guid ProfileId { get; set; }
+        public string HighestRole
+        {
            get
            {
                string _highestRole = "";
-                foreach (string role in Roles)
+                if (Roles != null)
                {
-                    switch (role)
+                    foreach (string role in Roles)
                    {
-                        case "Admin":
-                            // there is no higher
-                            _highestRole = role;
-                            break;
-                        case "Gamer":
-                            // only one high is Admin, so check for that
-                            if (_highestRole != "Admin")
-                            {
+                        switch (role)
+                        {
+                            case "Admin":
+                                // there is no higher
                                _highestRole = role;
-                            }
-                            break;
-                        case "Player":
-                            // make sure _highestRole isn't already set to Gamer or Admin
-                            if (_highestRole != "Admin" && _highestRole != "Gamer")
-                            {
-                                _highestRole = role;
-                            }
-                            break;
-                        default:
-                            _highestRole = "Player";
-                            break;
+                                break;
+                            case "Gamer":
+                                // only one high is Admin, so check for that
+                                if (_highestRole != "Admin")
+                                {
+                                    _highestRole = role;
+                                }
+                                break;
+                            case "Player":
+                                // make sure _highestRole isn't already set to Gamer or Admin
+                                if (_highestRole != "Admin" && _highestRole != "Gamer")
+                                {
+                                    _highestRole = role;
+                                }
+                                break;
+                            default:
+                                _highestRole = "Player";
+                                break;
+                        }
                    }
                }
+                else
+                {
+                    _highestRole = "Player";
+                }

                return _highestRole;
            }
--- a/gaseous-server/Classes/Common.cs
+++ b/gaseous-server/Classes/Common.cs
@@ -1,5 +1,6 @@
 using System.Collections.Concurrent;
 using System.ComponentModel;
+using System.Data;
 using System.IO.Compression;
 using System.Reflection;
 using System.Security.Cryptography;
@@ -19,7 +20,8 @@ namespace gaseous_server.Classes
 			if (ObjectToCheck == null || ObjectToCheck == System.DBNull.Value)
 			{
 				return IfNullValue;
-			} else
+			}
+			else
 			{
 				return ObjectToCheck;
 			}
@@ -27,10 +29,10 @@ namespace gaseous_server.Classes

 		static public DateTime ConvertUnixToDateTime(double UnixTimeStamp)
 		{
-            DateTime dateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
-            dateTime = dateTime.AddSeconds(UnixTimeStamp).ToLocalTime();
-            return dateTime;
-        }
+			DateTime dateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
+			dateTime = dateTime.AddSeconds(UnixTimeStamp).ToLocalTime();
+			return dateTime;
+		}

 		public class hashObject
 		{
@@ -41,21 +43,23 @@ namespace gaseous_server.Classes

 			public hashObject(string FileName)
 			{
-                var xmlStream = File.OpenRead(FileName);
+				var xmlStream = File.OpenRead(FileName);

-                var md5 = MD5.Create();
-                byte[] md5HashByte = md5.ComputeHash(xmlStream);
-                string md5Hash = BitConverter.ToString(md5HashByte).Replace("-", "").ToLowerInvariant();
+				Logging.Log(Logging.LogType.Information, "Hash File", "Generating MD5 hash for file: " + FileName);
+				var md5 = MD5.Create();
+				byte[] md5HashByte = md5.ComputeHash(xmlStream);
+				string md5Hash = BitConverter.ToString(md5HashByte).Replace("-", "").ToLowerInvariant();
 				_md5hash = md5Hash;

-                var sha1 = SHA1.Create();
+				Logging.Log(Logging.LogType.Information, "Hash File", "Generating SHA1 hash for file: " + FileName);
+				var sha1 = SHA1.Create();
 				xmlStream.Position = 0;
-                byte[] sha1HashByte = sha1.ComputeHash(xmlStream);
-                string sha1Hash = BitConverter.ToString(sha1HashByte).Replace("-", "").ToLowerInvariant();
+				byte[] sha1HashByte = sha1.ComputeHash(xmlStream);
+				string sha1Hash = BitConverter.ToString(sha1HashByte).Replace("-", "").ToLowerInvariant();
 				_sha1hash = sha1Hash;

 				xmlStream.Close();
-            }
+			}

 			string _md5hash = "";
 			string _sha1hash = "";
@@ -85,23 +89,23 @@ namespace gaseous_server.Classes
 			}
 		}

-        public static long DirSize(DirectoryInfo d)
-        {
-            long size = 0;
-            // Add file sizes.
-            FileInfo[] fis = d.GetFiles();
-            foreach (FileInfo fi in fis)
-            {
-                size += fi.Length;
-            }
-            // Add subdirectory sizes.
-            DirectoryInfo[] dis = d.GetDirectories();
-            foreach (DirectoryInfo di in dis)
-            {
-                size += DirSize(di);
-            }
-            return size;
-        }
+		public static long DirSize(DirectoryInfo d)
+		{
+			long size = 0;
+			// Add file sizes.
+			FileInfo[] fis = d.GetFiles();
+			foreach (FileInfo fi in fis)
+			{
+				size += fi.Length;
+			}
+			// Add subdirectory sizes.
+			DirectoryInfo[] dis = d.GetDirectories();
+			foreach (DirectoryInfo di in dis)
+			{
+				size += DirSize(di);
+			}
+			return size;
+		}

 		public static string[] SkippableFiles = {
 				".DS_STORE",
@@ -155,30 +159,74 @@ namespace gaseous_server.Classes
 				return defaultValue;
 			}
 		}
-    }
+
+		public static int GetLookupByCode(LookupTypes LookupType, string Code)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT Id FROM " + LookupType.ToString() + " WHERE Code = @code";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>{
+				{ "code", Code }
+			};
+
+			DataTable data = db.ExecuteCMD(sql, dbDict);
+			if (data.Rows.Count == 0)
+			{
+				return -1;
+			}
+			else
+			{
+				return (int)data.Rows[0]["Id"];
+			}
+		}
+
+		public static int GetLookupByValue(LookupTypes LookupType, string Value)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT Id FROM " + LookupType.ToString() + " WHERE Value = @value";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>{
+				{ "value", Value }
+			};
+
+			DataTable data = db.ExecuteCMD(sql, dbDict);
+			if (data.Rows.Count == 0)
+			{
+				return -1;
+			}
+			else
+			{
+				return (int)data.Rows[0]["Id"];
+			}
+		}
+
+		public enum LookupTypes
+		{
+			Country,
+			Language
+		}
+	}

 	/// <summary>
-    /// Provides a way to set contextual data that flows with the call and 
-    /// async context of a test or invocation.
-    /// </summary>
-    public static class CallContext
-    {
-        static ConcurrentDictionary<string, AsyncLocal<object>> state = new ConcurrentDictionary<string, AsyncLocal<object>>();
+	/// Provides a way to set contextual data that flows with the call and 
+	/// async context of a test or invocation.
+	/// </summary>
+	public static class CallContext
+	{
+		static ConcurrentDictionary<string, AsyncLocal<object>> state = new ConcurrentDictionary<string, AsyncLocal<object>>();

-        /// <summary>
-        /// Stores a given object and associates it with the specified name.
-        /// </summary>
-        /// <param name="name">The name with which to associate the new item in the call context.</param>
-        /// <param name="data">The object to store in the call context.</param>
-        public static void SetData(string name, object data) =>
-            state.GetOrAdd(name, _ => new AsyncLocal<object>()).Value = data;
+		/// <summary>
+		/// Stores a given object and associates it with the specified name.
+		/// </summary>
+		/// <param name="name">The name with which to associate the new item in the call context.</param>
+		/// <param name="data">The object to store in the call context.</param>
+		public static void SetData(string name, object data) =>
+			state.GetOrAdd(name, _ => new AsyncLocal<object>()).Value = data;

-        /// <summary>
-        /// Retrieves an object with the specified name from the <see cref="CallContext"/>.
-        /// </summary>
-        /// <param name="name">The name of the item in the call context.</param>
-        /// <returns>The object in the call context associated with the specified name, or <see langword="null"/> if not found.</returns>
-        public static object GetData(string name) =>
-            state.TryGetValue(name, out AsyncLocal<object> data) ? data.Value : null;
-    }
+		/// <summary>
+		/// Retrieves an object with the specified name from the <see cref="CallContext"/>.
+		/// </summary>
+		/// <param name="name">The name of the item in the call context.</param>
+		/// <returns>The object in the call context associated with the specified name, or <see langword="null"/> if not found.</returns>
+		public static object GetData(string name) =>
+			state.TryGetValue(name, out AsyncLocal<object> data) ? data.Value : null;
+	}
 }
--- a/gaseous-server/Classes/Config.cs
+++ b/gaseous-server/Classes/Config.cs
@@ -80,7 +80,8 @@ namespace gaseous_server.Classes
            get
            {
                string logPath = Path.Combine(ConfigurationPath, "Logs");
-                if (!Directory.Exists(logPath)) {
+                if (!Directory.Exists(logPath))
+                {
                    Directory.CreateDirectory(logPath);
                }
                return logPath;
@@ -131,7 +132,7 @@ namespace gaseous_server.Classes
                                _config.DatabaseConfiguration.DatabaseName = (string)Common.GetEnvVar("dbname", _config.DatabaseConfiguration.DatabaseName);
                                _config.DatabaseConfiguration.Port = int.Parse((string)Common.GetEnvVar("dbport", _config.DatabaseConfiguration.Port.ToString()));
                                _config.MetadataConfiguration.MetadataSource = (HasheousClient.Models.MetadataModel.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.MetadataSources), (string)Common.GetEnvVar("metadatasource", _config.MetadataConfiguration.MetadataSource.ToString()));
-                                _config.MetadataConfiguration.SignatureSource = (HasheousClient.Models.MetadataModel.SignatureSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.SignatureSources), (string)Common.GetEnvVar("signaturesource", _config.MetadataConfiguration.SignatureSource.ToString()));;
+                                _config.MetadataConfiguration.SignatureSource = (HasheousClient.Models.MetadataModel.SignatureSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.SignatureSources), (string)Common.GetEnvVar("signaturesource", _config.MetadataConfiguration.SignatureSource.ToString())); ;
                                _config.MetadataConfiguration.MaxLibraryScanWorkers = int.Parse((string)Common.GetEnvVar("maxlibraryscanworkers", _config.MetadataConfiguration.MaxLibraryScanWorkers.ToString()));
                                _config.MetadataConfiguration.HasheousHost = (string)Common.GetEnvVar("hasheoushost", _config.MetadataConfiguration.HasheousHost);
                                _config.IGDBConfiguration.ClientId = (string)Common.GetEnvVar("igdbclientid", _config.IGDBConfiguration.ClientId);
@@ -153,8 +154,8 @@ namespace gaseous_server.Classes
                }
            }

-            Console.WriteLine("Using configuration:");
-            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(_config, Formatting.Indented));
+            // Console.WriteLine("Using configuration:");
+            // Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(_config, Formatting.Indented));
        }

        public static void UpdateConfig()
@@ -196,17 +197,12 @@ namespace gaseous_server.Classes
            {
                string SettingName = (string)dataRow["Setting"];

-                if (SettingName.StartsWith("LastRun_"))
-                {
-                    Console.WriteLine("Break");
-                }
-
                if (AppSettings.ContainsKey(SettingName))
                {
                    AppSettings.Remove(SettingName);
                }

-                Logging.Log(Logging.LogType.Information, "Load Settings", "Loading setting " + SettingName + " from database");
+                // Logging.Log(Logging.LogType.Information, "Load Settings", "Loading setting " + SettingName + " from database");

                try
                {
@@ -427,7 +423,8 @@ namespace gaseous_server.Classes

            public class Database
            {
-                private static string _DefaultHostName {
+                private static string _DefaultHostName
+                {
                    get
                    {
                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbhost")))
@@ -643,7 +640,7 @@ namespace gaseous_server.Classes
                    return MetadataPath;
                }

-                public string LibrarySignatureImportDirectory
+                public string LibrarySignaturesDirectory
                {
                    get
                    {
@@ -651,6 +648,14 @@ namespace gaseous_server.Classes
                    }
                }

+                public string LibrarySignaturesProcessedDirectory
+                {
+                    get
+                    {
+                        return Path.Combine(LibraryRootDirectory, "Signatures - Processed");
+                    }
+                }
+
                public void InitLibrary()
                {
                    if (!Directory.Exists(LibraryRootDirectory)) { Directory.CreateDirectory(LibraryRootDirectory); }
@@ -660,7 +665,8 @@ namespace gaseous_server.Classes
                    if (!Directory.Exists(LibraryMetadataDirectory)) { Directory.CreateDirectory(LibraryMetadataDirectory); }
                    if (!Directory.Exists(LibraryTempDirectory)) { Directory.CreateDirectory(LibraryTempDirectory); }
                    if (!Directory.Exists(LibraryCollectionsDirectory)) { Directory.CreateDirectory(LibraryCollectionsDirectory); }
-                    if (!Directory.Exists(LibrarySignatureImportDirectory)) { Directory.CreateDirectory(LibrarySignatureImportDirectory); }
+                    if (!Directory.Exists(LibrarySignaturesDirectory)) { Directory.CreateDirectory(LibrarySignaturesDirectory); }
+                    if (!Directory.Exists(LibrarySignaturesProcessedDirectory)) { Directory.CreateDirectory(LibrarySignaturesProcessedDirectory); }
                }
            }

@@ -696,6 +702,10 @@ namespace gaseous_server.Classes
                    }
                }

+                private static bool _HasheousSubmitFixes { get; set; } = false;
+
+                private static string _HasheousAPIKey { get; set; } = "";
+
                private static int _MaxLibraryScanWorkers
                {
                    get
@@ -730,6 +740,10 @@ namespace gaseous_server.Classes

                public HasheousClient.Models.MetadataModel.SignatureSources SignatureSource = _SignatureSource;

+                public bool HasheousSubmitFixes = _HasheousSubmitFixes;
+
+                public string HasheousAPIKey = _HasheousAPIKey;
+
                public int MaxLibraryScanWorkers = _MaxLibraryScanWorkers;

                public string HasheousHost = _HasheousHost;
--- a/gaseous-server/Classes/Database.cs
+++ b/gaseous-server/Classes/Database.cs
@@ -70,39 +70,41 @@ namespace gaseous_server.Classes

 		public void InitDB()
 		{
-            // load resources
-            var assembly = Assembly.GetExecutingAssembly();
+			// load resources
+			var assembly = Assembly.GetExecutingAssembly();

-            switch (_ConnectorType)
+			DatabaseMemoryCacheOptions? CacheOptions = new DatabaseMemoryCacheOptions(false);
+
+			switch (_ConnectorType)
 			{
 				case databaseType.MySql:
 					// check if the database exists first - first run must have permissions to create a database
 					string sql = "CREATE DATABASE IF NOT EXISTS `" + Config.DatabaseConfiguration.DatabaseName + "`;";
 					Dictionary<string, object> dbDict = new Dictionary<string, object>();
 					Logging.Log(Logging.LogType.Information, "Database", "Creating database if it doesn't exist");
-					ExecuteCMD(sql, dbDict, 30, "server=" + Config.DatabaseConfiguration.HostName + ";port=" + Config.DatabaseConfiguration.Port + ";userid=" + Config.DatabaseConfiguration.UserName + ";password=" + Config.DatabaseConfiguration.Password);
+					ExecuteCMD(sql, dbDict, CacheOptions, 30, "server=" + Config.DatabaseConfiguration.HostName + ";port=" + Config.DatabaseConfiguration.Port + ";userid=" + Config.DatabaseConfiguration.UserName + ";password=" + Config.DatabaseConfiguration.Password);

 					// check if schema version table is in place - if not, create the schema version table
 					sql = "SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = '" + Config.DatabaseConfiguration.DatabaseName + "' AND TABLE_NAME = 'schema_version';";
-					DataTable SchemaVersionPresent = ExecuteCMD(sql, dbDict);
+					DataTable SchemaVersionPresent = ExecuteCMD(sql, dbDict, CacheOptions);
 					if (SchemaVersionPresent.Rows.Count == 0)
 					{
-                        // no schema table present - create it
-                        Logging.Log(Logging.LogType.Information, "Database", "Schema version table doesn't exist. Creating it.");
-                        sql = "CREATE TABLE `schema_version` (`schema_version` INT NOT NULL, PRIMARY KEY (`schema_version`)); INSERT INTO `schema_version` (`schema_version`) VALUES (0);";
-						ExecuteCMD(sql, dbDict);
+						// no schema table present - create it
+						Logging.Log(Logging.LogType.Information, "Database", "Schema version table doesn't exist. Creating it.");
+						sql = "CREATE TABLE `schema_version` (`schema_version` INT NOT NULL, PRIMARY KEY (`schema_version`)); INSERT INTO `schema_version` (`schema_version`) VALUES (0);";
+						ExecuteCMD(sql, dbDict, CacheOptions);
 					}

 					sql = "SELECT schema_version FROM schema_version;";
 					dbDict = new Dictionary<string, object>();
-					DataTable SchemaVersion = ExecuteCMD(sql, dbDict);
+					DataTable SchemaVersion = ExecuteCMD(sql, dbDict, CacheOptions);
 					int OuterSchemaVer = (int)SchemaVersion.Rows[0][0];
 					if (OuterSchemaVer == 0)
 					{
 						OuterSchemaVer = 1000;
 					}

-                    for (int i = OuterSchemaVer; i < 10000; i++)
+					for (int i = OuterSchemaVer; i < 10000; i++)
 					{
 						string resourceName = "gaseous_server.Support.Database.MySQL.gaseous-" + i + ".sql";
 						string dbScript = "";
@@ -113,25 +115,25 @@ namespace gaseous_server.Classes
 							using (Stream stream = assembly.GetManifestResourceStream(resourceName))
 							using (StreamReader reader = new StreamReader(stream))
 							{
-                                dbScript = reader.ReadToEnd();
+								dbScript = reader.ReadToEnd();

 								// apply script
 								sql = "SELECT schema_version FROM schema_version;";
 								dbDict = new Dictionary<string, object>();
-								SchemaVersion = ExecuteCMD(sql, dbDict);
+								SchemaVersion = ExecuteCMD(sql, dbDict, CacheOptions);
 								if (SchemaVersion.Rows.Count == 0)
 								{
-                                    // something is broken here... where's the table?
-                                    Logging.Log(Logging.LogType.Critical, "Database", "Schema table missing! This shouldn't happen!");
-                                    throw new Exception("schema_version table is missing!");
+									// something is broken here... where's the table?
+									Logging.Log(Logging.LogType.Critical, "Database", "Schema table missing! This shouldn't happen!");
+									throw new Exception("schema_version table is missing!");
 								}
 								else
 								{
 									int SchemaVer = (int)SchemaVersion.Rows[0][0];
-                                    Logging.Log(Logging.LogType.Information, "Database", "Schema version is " + SchemaVer);
+									Logging.Log(Logging.LogType.Information, "Database", "Schema version is " + SchemaVer);
 									// update schema version variable
 									Database.schema_version = SchemaVer;
-                                    if (SchemaVer < i)
+									if (SchemaVer < i)
 									{
 										try
 										{
@@ -140,12 +142,12 @@ namespace gaseous_server.Classes

 											// apply schema!
 											Logging.Log(Logging.LogType.Information, "Database", "Updating schema to version " + i);
-											ExecuteCMD(dbScript, dbDict, 180);
+											ExecuteCMD(dbScript, dbDict, CacheOptions, 180);

 											sql = "UPDATE schema_version SET schema_version=@schemaver";
 											dbDict = new Dictionary<string, object>();
 											dbDict.Add("schemaver", i);
-											ExecuteCMD(sql, dbDict);
+											ExecuteCMD(sql, dbDict, CacheOptions);

 											// run post-upgrade code
 											DatabaseMigration.PostUpgradeScript(i, _ConnectorType);
@@ -162,47 +164,91 @@ namespace gaseous_server.Classes
 								}
 							}
 						}
-                    }
-                    Logging.Log(Logging.LogType.Information, "Database", "Database setup complete");
-                    break;
+					}
+					Logging.Log(Logging.LogType.Information, "Database", "Database setup complete");
+					break;
 			}
 		}

-        public DataTable ExecuteCMD(string Command)
+		public DataTable ExecuteCMD(string Command)
 		{
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			return _ExecuteCMD(Command, dbDict, 30, "");
+			return _ExecuteCMD(Command, dbDict, CacheOptions, 30, "");
 		}

-        public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters)
-        {
-            return _ExecuteCMD(Command, Parameters, 30, "");
-        }
+		public DataTable ExecuteCMD(string Command, DatabaseMemoryCacheOptions? CacheOptions)
+		{
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			return _ExecuteCMD(Command, dbDict, CacheOptions, 30, "");
+		}

-        public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-			return _ExecuteCMD(Command, Parameters, Timeout, ConnectionString);
-        }
+		public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters)
+		{
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
+			return _ExecuteCMD(Command, Parameters, CacheOptions, 30, "");
+		}
+
+		public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions)
+		{
+			return _ExecuteCMD(Command, Parameters, CacheOptions, 30, "");
+		}
+
+		public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+		{
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
+			return _ExecuteCMD(Command, Parameters, CacheOptions, Timeout, ConnectionString);
+		}
+
+		public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions, int Timeout = 30, string ConnectionString = "")
+		{
+			return _ExecuteCMD(Command, Parameters, CacheOptions, Timeout, ConnectionString);
+		}

 		public List<Dictionary<string, object>> ExecuteCMDDict(string Command)
 		{
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			return _ExecuteCMDDict(Command, dbDict, 30, "");
+			return _ExecuteCMDDict(Command, dbDict, CacheOptions, 30, "");
 		}

-        public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters)
-        {
-            return _ExecuteCMDDict(Command, Parameters, 30, "");
-        }
-
-        public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-			return _ExecuteCMDDict(Command, Parameters, Timeout, ConnectionString);
-        }
-
-		private List<Dictionary<string, object>> _ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, DatabaseMemoryCacheOptions? CacheOptions)
 		{
-			DataTable dataTable = _ExecuteCMD(Command, Parameters, Timeout, ConnectionString);
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			return _ExecuteCMDDict(Command, dbDict, CacheOptions, 30, "");
+		}
+
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters)
+		{
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
+			return _ExecuteCMDDict(Command, Parameters, CacheOptions, 30, "");
+		}
+
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions)
+		{
+			return _ExecuteCMDDict(Command, Parameters, CacheOptions, 30, "");
+		}
+
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+		{
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
+			return _ExecuteCMDDict(Command, Parameters, CacheOptions, Timeout, ConnectionString);
+		}
+
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions, int Timeout = 30, string ConnectionString = "")
+		{
+			return _ExecuteCMDDict(Command, Parameters, CacheOptions, Timeout, ConnectionString);
+		}
+
+		private List<Dictionary<string, object>> _ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions, int Timeout = 30, string ConnectionString = "")
+		{
+			DataTable dataTable = _ExecuteCMD(Command, Parameters, CacheOptions, Timeout, ConnectionString);

 			// convert datatable to dictionary
 			List<Dictionary<string, object?>> rows = new List<Dictionary<string, object?>>();
@@ -228,18 +274,49 @@ namespace gaseous_server.Classes
 			return rows;
 		}

-        private DataTable _ExecuteCMD(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-            if (ConnectionString == "") { ConnectionString = _ConnectionString; }
-            switch (_ConnectorType)
-            {
-                case databaseType.MySql:
-                    MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
-                    return (DataTable)conn.ExecCMD(Command, Parameters, Timeout);
-                default:
-                    return new DataTable();
-            }
-        }
+		private DataTable _ExecuteCMD(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions, int Timeout = 30, string ConnectionString = "")
+		{
+			string CacheKey = Command + string.Join(";", Parameters.Select(x => string.Join("=", x.Key, x.Value)));
+
+			if (CacheOptions is object && CacheOptions.CacheEnabled)
+			{
+				object? CachedData = DatabaseMemoryCache.GetCacheObject(CacheKey);
+				if (CachedData is object)
+				{
+					return (DataTable)CachedData;
+				}
+			}
+
+			// purge cache if command contains "INSERT", "UPDATE", "DELETE", or "ALTER"
+			if (
+				Command.Contains("INSERT", StringComparison.InvariantCultureIgnoreCase) ||
+				Command.Contains("UPDATE", StringComparison.InvariantCultureIgnoreCase) ||
+				Command.Contains("DELETE", StringComparison.InvariantCultureIgnoreCase) ||
+				Command.Contains("ALTER", StringComparison.InvariantCultureIgnoreCase)
+				)
+			{
+				// exclude logging events from purging the cache
+				if (!Command.StartsWith("INSERT INTO SERVERLOGS", StringComparison.InvariantCultureIgnoreCase))
+				{
+					DatabaseMemoryCache.ClearCache();
+				}
+			}
+
+			if (ConnectionString == "") { ConnectionString = _ConnectionString; }
+			switch (_ConnectorType)
+			{
+				case databaseType.MySql:
+					MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
+					DataTable RetTable = conn.ExecCMD(Command, Parameters, Timeout);
+					if (CacheOptions is object && CacheOptions.CacheEnabled)
+					{
+						DatabaseMemoryCache.SetCacheObject(CacheKey, RetTable, CacheOptions.ExpirationSeconds);
+					}
+					return RetTable;
+				default:
+					return new DataTable();
+			}
+		}

 		public int ExecuteNonQuery(string Command)
 		{
@@ -247,52 +324,194 @@ namespace gaseous_server.Classes
 			return _ExecuteNonQuery(Command, dbDict, 30, "");
 		}

-        public int ExecuteNonQuery(string Command, Dictionary<string, object> Parameters)
-        {
-            return _ExecuteNonQuery(Command, Parameters, 30, "");
-        }
+		public int ExecuteNonQuery(string Command, Dictionary<string, object> Parameters)
+		{
+			return _ExecuteNonQuery(Command, Parameters, 30, "");
+		}

-        public int ExecuteNonQuery(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
+		public int ExecuteNonQuery(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+		{
 			return _ExecuteNonQuery(Command, Parameters, Timeout, ConnectionString);
-        }
+		}

-        private int _ExecuteNonQuery(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-            if (ConnectionString == "") { ConnectionString = _ConnectionString; }
-            switch (_ConnectorType)
-            {
-                case databaseType.MySql:
-                    MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
+		private int _ExecuteNonQuery(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+		{
+			if (ConnectionString == "") { ConnectionString = _ConnectionString; }
+			switch (_ConnectorType)
+			{
+				case databaseType.MySql:
+					MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
 					int retVal = conn.ExecNonQuery(Command, Parameters, Timeout);
-                    return retVal;
-                default:
-                    return 0;
-            }
-        }
+					return retVal;
+				default:
+					return 0;
+			}
+		}

-        public void ExecuteTransactionCMD(List<SQLTransactionItem> CommandList, int Timeout = 60)
-        {
-            object conn;
-            switch (_ConnectorType)
-            {
-                case databaseType.MySql:
-                    {
-                        var commands = new List<Dictionary<string, object>>();
-                        foreach (SQLTransactionItem CommandItem in CommandList)
-                        {
-                            var nCmd = new Dictionary<string, object>();
-                            nCmd.Add("sql", CommandItem.SQLCommand);
-                            nCmd.Add("values", CommandItem.Parameters);
-                            commands.Add(nCmd);
-                        }
+		public void ExecuteTransactionCMD(List<SQLTransactionItem> CommandList, int Timeout = 60)
+		{
+			object conn;
+			switch (_ConnectorType)
+			{
+				case databaseType.MySql:
+					{
+						var commands = new List<Dictionary<string, object>>();
+						foreach (SQLTransactionItem CommandItem in CommandList)
+						{
+							var nCmd = new Dictionary<string, object>();
+							nCmd.Add("sql", CommandItem.SQLCommand);
+							nCmd.Add("values", CommandItem.Parameters);
+							commands.Add(nCmd);
+						}

-                        conn = new MySQLServerConnector(_ConnectionString);
-                        ((MySQLServerConnector)conn).TransactionExecCMD(commands, Timeout);
-                        break;
-                    }
-            }
-        }
+						conn = new MySQLServerConnector(_ConnectionString);
+						((MySQLServerConnector)conn).TransactionExecCMD(commands, Timeout);
+						break;
+					}
+			}
+		}
+
+		public static class DatabaseMemoryCache
+		{
+			private class MemoryCacheItem
+			{
+				public MemoryCacheItem(object CacheObject)
+				{
+					cacheObject = CacheObject;
+				}
+
+				public MemoryCacheItem(object CacheObject, int ExpirationSeconds)
+				{
+					cacheObject = CacheObject;
+					expirationSeconds = ExpirationSeconds;
+				}
+
+				/// <summary>
+				/// The time the object was added to the cache in ticks
+				/// </summary>
+				public long addedTime { get; } = Environment.TickCount64;
+
+				/// <summary>
+				/// The time the object will expire in ticks
+				/// </summary>
+				public long expirationTime
+				{
+					get
+					{
+						return addedTime + _expirationTicks;
+					}
+				}
+
+				/// <summary>
+				/// The number of seconds the object will be cached
+				/// </summary>
+				public int expirationSeconds
+				{
+					get
+					{
+						return (int)TimeSpan.FromTicks(_expirationTicks).Seconds;
+					}
+					set
+					{
+						_expirationTicks = (long)TimeSpan.FromSeconds(value).Ticks;
+					}
+				}
+
+				private long _expirationTicks = (long)TimeSpan.FromSeconds(2).Ticks;
+
+				/// <summary>
+				/// The object to be cached
+				/// </summary>
+				public object cacheObject { get; set; }
+			}
+			private static Dictionary<string, MemoryCacheItem> MemoryCache = new Dictionary<string, MemoryCacheItem>();
+			private static Timer CacheTimer = new Timer(CacheTimerCallback, null, 0, 1000);
+
+			private static void CacheTimerCallback(object? state)
+			{
+				ClearExpiredCache();
+			}
+
+			public static object? GetCacheObject(string CacheKey)
+			{
+				if (MemoryCache.ContainsKey(CacheKey))
+				{
+					if (MemoryCache[CacheKey].expirationTime < Environment.TickCount)
+					{
+						MemoryCache.Remove(CacheKey);
+						return null;
+					}
+					else
+					{
+						return MemoryCache[CacheKey].cacheObject;
+					}
+				}
+				else
+				{
+					return null;
+				}
+			}
+			public static void SetCacheObject(string CacheKey, object CacheObject, int ExpirationSeconds = 2)
+			{
+				try
+				{
+					if (MemoryCache.ContainsKey(CacheKey))
+					{
+						MemoryCache.Remove(CacheKey);
+					}
+					MemoryCache.Add(CacheKey, new MemoryCacheItem(CacheObject, ExpirationSeconds));
+				}
+				catch (Exception ex)
+				{
+					Logging.Log(Logging.LogType.Debug, "Database", "Error while setting cache object", ex);
+					ClearCache();
+				}
+			}
+			public static void RemoveCacheObject(string CacheKey)
+			{
+				if (MemoryCache.ContainsKey(CacheKey))
+				{
+					MemoryCache.Remove(CacheKey);
+				}
+			}
+			public static void ClearCache()
+			{
+				MemoryCache.Clear();
+			}
+			private static void ClearExpiredCache()
+			{
+				try
+				{
+					long currTime = Environment.TickCount64;
+
+					Dictionary<string, MemoryCacheItem> ExpiredItems = MemoryCache;
+					foreach (string key in ExpiredItems.Keys)
+					{
+						if (MemoryCache[key].expirationTime < currTime)
+						{
+							Console.WriteLine("\x1b[95mPurging expired cache item " + key + ". Added: " + MemoryCache[key].addedTime + ". Expired: " + MemoryCache[key].expirationTime);
+							MemoryCache.Remove(key);
+						}
+					}
+				}
+				catch (Exception ex)
+				{
+					Logging.Log(Logging.LogType.Debug, "Database", "Error while clearing expired cache", ex);
+				}
+			}
+		}
+
+		public class DatabaseMemoryCacheOptions
+		{
+			public DatabaseMemoryCacheOptions(bool CacheEnabled = false, int ExpirationSeconds = 1)
+			{
+				this.CacheEnabled = CacheEnabled;
+				this.ExpirationSeconds = ExpirationSeconds;
+			}
+
+			public bool CacheEnabled { get; set; }
+			public int ExpirationSeconds { get; set; }
+		}

 		public int GetDatabaseSchemaVersion()
 		{
@@ -319,17 +538,17 @@ namespace gaseous_server.Classes
 		public bool TestConnection()
 		{
 			switch (_ConnectorType)
-            {
-                case databaseType.MySql:
-                    MySQLServerConnector conn = new MySQLServerConnector(_ConnectionString);
-                    return conn.TestConnection();
-                default:
-                    return false;
-            }
+			{
+				case databaseType.MySql:
+					MySQLServerConnector conn = new MySQLServerConnector(_ConnectionString);
+					return conn.TestConnection();
+				default:
+					return false;
+			}
 		}

-        public class SQLTransactionItem
-        {
+		public class SQLTransactionItem
+		{
 			public SQLTransactionItem()
 			{

@@ -341,11 +560,11 @@ namespace gaseous_server.Classes
 				this.Parameters = Parameters;
 			}

-            public string? SQLCommand;
-            public Dictionary<string, object>? Parameters = new Dictionary<string, object>();
-        }
+			public string? SQLCommand;
+			public Dictionary<string, object>? Parameters = new Dictionary<string, object>();
+		}

-        private partial class MySQLServerConnector
+		private partial class MySQLServerConnector
 		{
 			private string DBConn = "";

@@ -358,8 +577,8 @@ namespace gaseous_server.Classes
 			{
 				DataTable RetTable = new DataTable();

-                Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
-                using (MySqlConnection conn = new MySqlConnection(DBConn))
+				Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
+				using (MySqlConnection conn = new MySqlConnection(DBConn))
 				{
 					conn.Open();

@@ -384,7 +603,9 @@ namespace gaseous_server.Classes
 							Logging.Log(Logging.LogType.Debug, "Database", "Parameters: " + dictValues, null, true);
 						}
 						RetTable.Load(cmd.ExecuteReader());
-					} catch (Exception ex) {
+					}
+					catch (Exception ex)
+					{
 						Logging.Log(Logging.LogType.Critical, "Database", "Error while executing '" + SQL + "'", ex);
 						Trace.WriteLine("Error executing " + SQL);
 						Trace.WriteLine("Full exception: " + ex.ToString());
@@ -397,12 +618,12 @@ namespace gaseous_server.Classes
 				return RetTable;
 			}

-			public int ExecNonQuery(string SQL, Dictionary< string, object> Parameters, int Timeout)
+			public int ExecNonQuery(string SQL, Dictionary<string, object> Parameters, int Timeout)
 			{
 				int result = 0;

-                Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
-                using (MySqlConnection conn = new MySqlConnection(DBConn))
+				Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
+				using (MySqlConnection conn = new MySqlConnection(DBConn))
 				{
 					conn.Open();

@@ -427,7 +648,9 @@ namespace gaseous_server.Classes
 							Logging.Log(Logging.LogType.Debug, "Database", "Parameters: " + dictValues, null, true);
 						}
 						result = cmd.ExecuteNonQuery();
-					} catch (Exception ex) {
+					}
+					catch (Exception ex)
+					{
 						Logging.Log(Logging.LogType.Critical, "Database", "Error while executing '" + SQL + "'", ex);
 						Trace.WriteLine("Error executing " + SQL);
 						Trace.WriteLine("Full exception: " + ex.ToString());
@@ -440,10 +663,10 @@ namespace gaseous_server.Classes
 				return result;
 			}

-            public void TransactionExecCMD(List<Dictionary<string, object>> Parameters, int Timeout)
-            {
-                using (MySqlConnection conn = new MySqlConnection(DBConn))
-                {
+			public void TransactionExecCMD(List<Dictionary<string, object>> Parameters, int Timeout)
+			{
+				using (MySqlConnection conn = new MySqlConnection(DBConn))
+				{
 					conn.Open();
 					var command = conn.CreateCommand();
 					MySqlTransaction transaction;
@@ -460,28 +683,28 @@ namespace gaseous_server.Classes
 					transaction.Commit();
 					conn.Close();
 				}
-            }
+			}

-            private MySqlCommand buildcommand(MySqlConnection Conn, string SQL, Dictionary<string, object> Parameters, int Timeout)
-            {
-                var cmd = new MySqlCommand();
-                cmd.Connection = Conn;
-                cmd.CommandText = SQL;
-                cmd.CommandTimeout = Timeout;
-                {
-                    var withBlock = cmd.Parameters;
-                    if (Parameters is object)
-                    {
-                        if (Parameters.Count > 0)
-                        {
-                            foreach (string param in Parameters.Keys)
-                                withBlock.AddWithValue(param, Parameters[param]);
-                        }
-                    }
-                }
+			private MySqlCommand buildcommand(MySqlConnection Conn, string SQL, Dictionary<string, object> Parameters, int Timeout)
+			{
+				var cmd = new MySqlCommand();
+				cmd.Connection = Conn;
+				cmd.CommandText = SQL;
+				cmd.CommandTimeout = Timeout;
+				{
+					var withBlock = cmd.Parameters;
+					if (Parameters is object)
+					{
+						if (Parameters.Count > 0)
+						{
+							foreach (string param in Parameters.Keys)
+								withBlock.AddWithValue(param, Parameters[param]);
+						}
+					}
+				}

-                return cmd;
-            }
+				return cmd;
+			}

 			public bool TestConnection()
 			{
@@ -499,7 +722,7 @@ namespace gaseous_server.Classes
 					}
 				}
 			}
-        }
-    }
+		}
+	}
 }

--- a/gaseous-server/Classes/DatabaseMigration.cs
+++ b/gaseous-server/Classes/DatabaseMigration.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Data;
 using System.Reflection;
+using gaseous_server.Classes.Metadata;
+using gaseous_server.Models;
+using IGDB.Models;

 namespace gaseous_server.Classes
 {
-	public static class DatabaseMigration
-	{
+    public static class DatabaseMigration
+    {
        public static List<int> BackgroundUpgradeTargetSchemaVersions = new List<int>();

        public static void PreUpgradeScript(int TargetSchemaVersion, Database.databaseType? DatabaseType)
@@ -20,7 +23,7 @@ namespace gaseous_server.Classes

            Logging.Log(Logging.LogType.Information, "Database", "Checking for pre-upgrade for schema version " + TargetSchemaVersion);

-            switch(DatabaseType)
+            switch (DatabaseType)
            {
                case Database.databaseType.MySql:
                    switch (TargetSchemaVersion)
@@ -64,12 +67,14 @@ namespace gaseous_server.Classes

        public static void PostUpgradeScript(int TargetSchemaVersion, Database.databaseType? DatabaseType)
        {
+            var assembly = Assembly.GetExecutingAssembly();
+
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
            string sql = "";
            Dictionary<string, object> dbDict = new Dictionary<string, object>();
            DataTable data;

-            switch(DatabaseType)
+            switch (DatabaseType)
            {
                case Database.databaseType.MySql:
                    switch (TargetSchemaVersion)
@@ -103,6 +108,80 @@ namespace gaseous_server.Classes
                            sql = "DELETE FROM Settings WHERE Setting LIKE 'LastRun_%';";
                            db.ExecuteNonQuery(sql);
                            break;
+
+                        case 1023:
+                            // load country list
+                            Logging.Log(Logging.LogType.Information, "Database Upgrade", "Adding country look up table contents");
+
+                            string countryResourceName = "gaseous_server.Support.Country.txt";
+                            using (Stream stream = assembly.GetManifestResourceStream(countryResourceName))
+                            using (StreamReader reader = new StreamReader(stream))
+                            {
+                                do
+                                {
+                                    string[] line = reader.ReadLine().Split("|");
+
+                                    sql = "INSERT INTO Country (Code, Value) VALUES (@code, @value);";
+                                    dbDict = new Dictionary<string, object>{
+                                { "code", line[0] },
+                                { "value", line[1] }
+                            };
+                                    db.ExecuteNonQuery(sql, dbDict);
+                                } while (reader.EndOfStream == false);
+                            }
+
+                            // load language list
+                            Logging.Log(Logging.LogType.Information, "Database Upgrade", "Adding language look up table contents");
+
+                            string languageResourceName = "gaseous_server.Support.Language.txt";
+                            using (Stream stream = assembly.GetManifestResourceStream(languageResourceName))
+                            using (StreamReader reader = new StreamReader(stream))
+                            {
+                                do
+                                {
+                                    string[] line = reader.ReadLine().Split("|");
+
+                                    sql = "INSERT INTO Language (Code, Value) VALUES (@code, @value);";
+                                    dbDict = new Dictionary<string, object>{
+                                { "code", line[0] },
+                                { "value", line[1] }
+                            };
+                                    db.ExecuteNonQuery(sql, dbDict);
+                                } while (reader.EndOfStream == false);
+                            }
+
+                            // this is a safe background task
+                            BackgroundUpgradeTargetSchemaVersions.Add(1023);
+                            break;
+
+                        case 1024:
+                            // create profiles for all existing users
+                            sql = "SELECT * FROM Users;";
+                            data = db.ExecuteCMD(sql);
+                            foreach (DataRow row in data.Rows)
+                            {
+                                // get legacy avatar from UserAvatars table
+                                sql = "SELECT Avatar FROM UserAvatars WHERE UserId = @userid;";
+                                dbDict = new Dictionary<string, object>
+                                {
+                                    { "userid", row["Id"] }
+                                };
+                                DataTable avatarData = db.ExecuteCMD(sql, dbDict);
+
+                                sql = "INSERT INTO UserProfiles (Id, UserId, DisplayName, Quip, Avatar, AvatarExtension, UnstructuredData) VALUES (@id, @userid, @displayname, @quip, @avatar, @avatarextension, @data);";
+                                dbDict = new Dictionary<string, object>
+                                {
+                                    { "id", Guid.NewGuid() },
+                                    { "userid", row["Id"] },
+                                    { "displayname", row["Email"] },
+                                    { "quip", "" },
+                                    { "avatar", avatarData.Rows.Count > 0 ? avatarData.Rows[0]["Avatar"] : null },
+                                    { "avatarextension", avatarData.Rows.Count > 0 ? ".jpg" : null },
+                                    { "data", "{}" }
+                                };
+                                db.ExecuteNonQuery(sql, dbDict);
+                            }
+                            break;
                    }
                    break;
            }
@@ -117,11 +196,16 @@ namespace gaseous_server.Classes
                    case 1002:
                        MySql_1002_MigrateMetadataVersion();
                        break;
+
+                    case 1023:
+                        MySql_1023_MigrateMetadataVersion();
+                        break;
                }
            }
        }

-        public static void MySql_1002_MigrateMetadataVersion() {
+        public static void MySql_1002_MigrateMetadataVersion()
+        {
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
            string sql = "";
            Dictionary<string, object> dbDict = new Dictionary<string, object>();
@@ -216,5 +300,39 @@ namespace gaseous_server.Classes
                }
            }
        }
+
+        public static void MySql_1023_MigrateMetadataVersion()
+        {
+            FileSignature fileSignature = new FileSignature();
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM Games_Roms WHERE RomDataVersion = 1;";
+            DataTable data = db.ExecuteCMD(sql);
+            long count = 1;
+            foreach (DataRow row in data.Rows)
+            {
+                Logging.Log(Logging.LogType.Information, "Database Migration", "Updating ROM table for ROM (" + count + " / " + data.Rows.Count + "): " + (string)row["Name"]);
+
+                GameLibrary.LibraryItem library = GameLibrary.GetLibrary((int)row["LibraryId"]);
+                Common.hashObject hash = new Common.hashObject()
+                {
+                    md5hash = (string)row["MD5"],
+                    sha1hash = (string)row["SHA1"]
+                };
+                Signatures_Games signature = fileSignature.GetFileSignature(
+                    library,
+                    hash,
+                    new FileInfo((string)row["Path"]),
+                    (string)row["Path"]
+                );
+
+                Platform platform = Platforms.GetPlatform((long)row["PlatformId"], false);
+                Game game = Games.GetGame((long)row["GameId"], false, false, false);
+
+                ImportGame.StoreROM(library, hash, game, platform, signature, (string)row["Path"], (long)row["Id"]);
+
+                count += 1;
+            }
+        }
    }
 }
--- a/gaseous-server/Classes/FileSignature.cs
+++ b/gaseous-server/Classes/FileSignature.cs
@@ -1,6 +1,9 @@
 using System.Collections.Concurrent;
 using System.IO.Compression;
+using System.Net;
+using gaseous_server.Classes.Metadata;
 using HasheousClient.Models;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using NuGet.Common;
 using SevenZip;
 using SharpCompress.Archives;
@@ -31,7 +34,7 @@ namespace gaseous_server.Classes
                if (!Directory.Exists(ExtractPath)) { Directory.CreateDirectory(ExtractPath); }
                try
                {
-                    switch(ImportedFileExtension)
+                    switch (ImportedFileExtension)
                    {
                        case ".zip":
                            Logging.Log(Logging.LogType.Information, "Get Signature", "Decompressing using zip");
@@ -110,8 +113,10 @@ namespace gaseous_server.Classes
                    // loop through contents until we find the first signature match
                    List<ArchiveData> archiveFiles = new List<ArchiveData>();
                    bool signatureFound = false;
+                    bool signatureSelectorAlreadyApplied = false;
                    foreach (string file in Directory.GetFiles(ExtractPath, "*.*", SearchOption.AllDirectories))
                    {
+                        bool signatureSelector = false;
                        if (File.Exists(file))
                        {
                            FileInfo zfi = new FileInfo(file);
@@ -121,15 +126,6 @@ namespace gaseous_server.Classes

                            if (zfi != null)
                            {
-                                ArchiveData archiveData = new ArchiveData{
-                                    FileName = Path.GetFileName(file),
-                                    FilePath = zfi.Directory.FullName.Replace(ExtractPath, ""),
-                                    Size = zfi.Length,
-                                    MD5 = hash.md5hash,
-                                    SHA1 = hash.sha1hash
-                                };
-                                archiveFiles.Add(archiveData);
-
                                if (signatureFound == false)
                                {
                                    gaseous_server.Models.Signatures_Games zDiscoveredSignature = _GetFileSignature(zhash, zfi.Name, zfi.Extension, zfi.Length, file, true);
@@ -151,15 +147,37 @@ namespace gaseous_server.Classes
                                        discoveredSignature = zDiscoveredSignature;

                                        signatureFound = true;
+
+                                        if (signatureSelectorAlreadyApplied == false)
+                                        {
+                                            signatureSelector = true;
+                                            signatureSelectorAlreadyApplied = true;
+                                        }
                                    }
                                }
+
+                                ArchiveData archiveData = new ArchiveData
+                                {
+                                    FileName = Path.GetFileName(file),
+                                    FilePath = zfi.Directory.FullName.Replace(ExtractPath, ""),
+                                    Size = zfi.Length,
+                                    MD5 = zhash.md5hash,
+                                    SHA1 = zhash.sha1hash,
+                                    isSignatureSelector = signatureSelector
+                                };
+                                archiveFiles.Add(archiveData);
                            }
                        }
                    }

-                    discoveredSignature.Rom.Attributes.Add(new KeyValuePair<string, object>(
+                    if (discoveredSignature.Rom.Attributes == null)
+                    {
+                        discoveredSignature.Rom.Attributes = new Dictionary<string, object>();
+                    }
+
+                    discoveredSignature.Rom.Attributes.Add(
                         "ZipContents", Newtonsoft.Json.JsonConvert.SerializeObject(archiveFiles)
-                    ));
+                    );
                }
                catch (Exception ex)
                {
@@ -175,37 +193,45 @@ namespace gaseous_server.Classes
            Logging.Log(Logging.LogType.Information, "Import Game", "Checking signature for file: " + GameFileImportPath + "\nMD5 hash: " + hash.md5hash + "\nSHA1 hash: " + hash.sha1hash);


-            gaseous_server.Models.Signatures_Games discoveredSignature = new gaseous_server.Models.Signatures_Games();
+            gaseous_server.Models.Signatures_Games? discoveredSignature = null;

-            // do database search first
-            gaseous_server.Models.Signatures_Games? dbSignature = _GetFileSignatureFromDatabase(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
-
-            if (dbSignature != null)
+            // begin signature search
+            switch (Config.MetadataConfiguration.SignatureSource)
            {
-                // local signature found
-                Logging.Log(Logging.LogType.Information, "Import Game", "Signature found in local database for game: " + dbSignature.Game.Name);
-                discoveredSignature = dbSignature;
+                case HasheousClient.Models.MetadataModel.SignatureSources.LocalOnly:
+                    Logging.Log(Logging.LogType.Information, "Import Game", "Hasheous disabled - searching local database only");
+
+                    discoveredSignature = _GetFileSignatureFromDatabase(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
+
+                    break;
+
+                case HasheousClient.Models.MetadataModel.SignatureSources.Hasheous:
+                    Logging.Log(Logging.LogType.Information, "Import Game", "Hasheous enabled - searching Hashesous and then local database if not found");
+
+                    discoveredSignature = _GetFileSignatureFromHasheous(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
+
+                    if (discoveredSignature == null)
+                    {
+                        Logging.Log(Logging.LogType.Information, "Import Game", "Signature not found in Hasheous - checking local database");
+
+                        discoveredSignature = _GetFileSignatureFromDatabase(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
+                    }
+                    else
+                    {
+                        Logging.Log(Logging.LogType.Information, "Import Game", "Signature retrieved from Hasheous for game: " + discoveredSignature.Game.Name);
+                    }
+                    break;
+
            }
-            else
+
+            if (discoveredSignature == null)
            {
-                // no local signature attempt to pull from Hasheous
-                dbSignature = _GetFileSignatureFromHasheous(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
+                // construct a signature from file data
+                Logging.Log(Logging.LogType.Information, "Import Game", "Signature not found in local database or Hasheous (if enabled) - generating from file data");

-                if (dbSignature != null)
-                {
-                    // signature retrieved from Hasheous
-                    Logging.Log(Logging.LogType.Information, "Import Game", "Signature retrieved from Hasheous for game: " + dbSignature.Game.Name);
+                discoveredSignature = _GetFileSignatureFromFileData(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);

-                    discoveredSignature = dbSignature;
-                }
-                else
-                {
-                    // construct a signature from file data
-                    dbSignature = _GetFileSignatureFromFileData(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
-                    Logging.Log(Logging.LogType.Information, "Import Game", "Signature generated from provided file for game: " + dbSignature.Game.Name);
-                
-                    discoveredSignature = dbSignature;
-                }
+                Logging.Log(Logging.LogType.Information, "Import Game", "Signature generated from provided file for game: " + discoveredSignature.Game.Name);
            }

            gaseous_server.Models.PlatformMapping.GetIGDBPlatformMapping(ref discoveredSignature, ImageExtension, false);
@@ -216,8 +242,8 @@ namespace gaseous_server.Classes
            return discoveredSignature;
        }

-		private gaseous_server.Models.Signatures_Games? _GetFileSignatureFromDatabase(Common.hashObject hash, string ImageName, string ImageExtension, long ImageSize, string GameFileImportPath)
-		{
+        private gaseous_server.Models.Signatures_Games? _GetFileSignatureFromDatabase(Common.hashObject hash, string ImageName, string ImageExtension, long ImageSize, string GameFileImportPath)
+        {
            Logging.Log(Logging.LogType.Information, "Get Signature", "Checking local database for MD5: " + hash.md5hash);

            // check 1: do we have a signature for it?
@@ -264,37 +290,97 @@ namespace gaseous_server.Classes
            if (Config.MetadataConfiguration.SignatureSource == HasheousClient.Models.MetadataModel.SignatureSources.Hasheous)
            {
                HasheousClient.Hasheous hasheous = new HasheousClient.Hasheous();
-                SignatureLookupItem? HasheousResult = hasheous.RetrieveFromHasheousAsync(new HashLookupModel{
-                    MD5 = hash.md5hash,
-                    SHA1 = hash.sha1hash
-                });
-
-                if (HasheousResult != null)
+                Console.WriteLine(HasheousClient.WebApp.HttpHelper.BaseUri);
+                LookupItemModel? HasheousResult = null;
+                try
                {
-                    if (HasheousResult.Signature != null)
+                    HasheousResult = hasheous.RetrieveFromHasheous(new HashLookupModel
                    {
-                        gaseous_server.Models.Signatures_Games signature = new Models.Signatures_Games();
-                        signature.Game = HasheousResult.Signature.Game;
-                        signature.Rom = HasheousResult.Signature.Rom;
+                        MD5 = hash.md5hash,
+                        SHA1 = hash.sha1hash
+                    });

-                        if (HasheousResult.MetadataResults != null)
+                    if (HasheousResult != null)
+                    {
+                        if (HasheousResult.Signature != null)
                        {
-                            if (HasheousResult.MetadataResults.Count > 0)
+                            gaseous_server.Models.Signatures_Games signature = new Models.Signatures_Games();
+                            string gameJson = Newtonsoft.Json.JsonConvert.SerializeObject(HasheousResult.Signature.Game);
+                            string romJson = Newtonsoft.Json.JsonConvert.SerializeObject(HasheousResult.Signature.Rom);
+                            signature.Game = Newtonsoft.Json.JsonConvert.DeserializeObject<Models.Signatures_Games.GameItem>(gameJson);
+                            signature.Rom = Newtonsoft.Json.JsonConvert.DeserializeObject<Models.Signatures_Games.RomItem>(romJson);
+
+                            // get platform metadata
+                            if (HasheousResult.Platform != null)
                            {
-                                foreach (SignatureLookupItem.MetadataResult metadataResult in HasheousResult.MetadataResults)
+                                if (HasheousResult.Platform.metadata.Count > 0)
                                {
-                                    if (metadataResult.Source == MetadataModel.MetadataSources.IGDB)
+                                    foreach (HasheousClient.Models.MetadataItem metadataResult in HasheousResult.Platform.metadata)
                                    {
-                                        signature.Flags.IGDBPlatformId = (long)metadataResult.PlatformId;
-                                        signature.Flags.IGDBGameId = (long)metadataResult.GameId;
+                                        if (metadataResult.Id.Length > 0)
+                                        {
+                                            switch (metadataResult.Source)
+                                            {
+                                                case HasheousClient.Models.MetadataSources.IGDB:
+                                                    signature.Flags.IGDBPlatformId = (long)Platforms.GetPlatform(metadataResult.Id, false).Id;
+                                                    break;
+                                            }
+                                        }
                                    }
                                }
                            }
-                        }

-                        return signature;
+                            // get game metadata
+                            if (HasheousResult.Metadata != null)
+                            {
+                                if (HasheousResult.Metadata.Count > 0)
+                                {
+                                    foreach (HasheousClient.Models.MetadataItem metadataResult in HasheousResult.Metadata)
+                                    {
+                                        if (metadataResult.Id.Length > 0)
+                                        {
+                                            switch (metadataResult.Source)
+                                            {
+                                                case HasheousClient.Models.MetadataSources.IGDB:
+                                                    signature.Flags.IGDBGameId = (long)Games.GetGame(metadataResult.Id, false, false, false).Id;
+                                                    break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            return signature;
+                        }
                    }
                }
+                catch (AggregateException aggEx)
+                {
+                    foreach (Exception ex in aggEx.InnerExceptions)
+                    {
+                        // get exception type
+                        if (ex is HttpRequestException)
+                        {
+                            if (ex.Message.Contains("404 (Not Found)"))
+                            {
+                                Logging.Log(Logging.LogType.Information, "Get Signature", "No signature found in Hasheous");
+                            }
+                            else
+                            {
+                                Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous", ex);
+                            }
+                        }
+                        else
+                        {
+                            Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous", ex);
+
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous", ex);
+                }
            }

            return null;
@@ -368,6 +454,7 @@ namespace gaseous_server.Classes
            public long Size { get; set; }
            public string MD5 { get; set; }
            public string SHA1 { get; set; }
+            public bool isSignatureSelector { get; set; } = false;
        }
    }
 }
--- a/gaseous-server/Classes/Filters.cs
+++ b/gaseous-server/Classes/Filters.cs
@@ -26,7 +26,7 @@ namespace gaseous_server.Classes

            string sql = "SELECT Platform.Id, Platform.`Name`, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, Games_Roms.PlatformId, COUNT(Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId WHERE (" + ageRestriction_Platform + ") GROUP BY Game.Id , Games_Roms.PlatformId HAVING RomCount > 0) Game JOIN Platform ON Game.PlatformId = Platform.Id GROUP BY Platform.`Name`;";

-            DataTable dbResponse = db.ExecuteCMD(sql);
+            DataTable dbResponse = db.ExecuteCMD(sql, new Database.DatabaseMemoryCacheOptions(CacheEnabled: true, ExpirationSeconds: 300));

            foreach (DataRow dr in dbResponse.Rows)
            {
@@ -83,7 +83,7 @@ namespace gaseous_server.Classes
            // age groups
            List<FilterItem> agegroupings = new List<FilterItem>();
            sql = "SELECT Game.AgeGroupId, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, AgeGroup.AgeGroupId, COUNT(Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId WHERE (" + ageRestriction_Platform + ") GROUP BY Game.Id HAVING RomCount > 0) Game GROUP BY Game.AgeGroupId ORDER BY Game.AgeGroupId DESC";
-            dbResponse = db.ExecuteCMD(sql);
+            dbResponse = db.ExecuteCMD(sql, new Database.DatabaseMemoryCacheOptions(CacheEnabled: true, ExpirationSeconds: 300));

            foreach (DataRow dr in dbResponse.Rows)
            {
@@ -114,7 +114,7 @@ namespace gaseous_server.Classes

            string sql = "SELECT <ITEMNAME>.Id, <ITEMNAME>.`Name`, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, AgeGroup.AgeGroupId, COUNT(Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId WHERE (" + AgeRestriction + ") GROUP BY Game.Id HAVING RomCount > 0) Game JOIN Relation_Game_<ITEMNAME>s ON Game.Id = Relation_Game_<ITEMNAME>s.GameId JOIN <ITEMNAME> ON Relation_Game_<ITEMNAME>s.<ITEMNAME>sId = <ITEMNAME>.Id GROUP BY <ITEMNAME>.`Name` ORDER BY <ITEMNAME>.`Name`;";
            sql = sql.Replace("<ITEMNAME>", Name);
-            DataTable dbResponse = db.ExecuteCMD(sql);
+            DataTable dbResponse = db.ExecuteCMD(sql, new Database.DatabaseMemoryCacheOptions(CacheEnabled: true, ExpirationSeconds: 300));

            return dbResponse;
        }
--- a/gaseous-server/Classes/GameLibrary.cs
+++ b/gaseous-server/Classes/GameLibrary.cs
@@ -7,37 +7,37 @@ using Microsoft.CodeAnalysis.FlowAnalysis.DataFlow;

 namespace gaseous_server
 {
-	public static class GameLibrary
-	{
+    public static class GameLibrary
+    {
        // exceptions
        public class PathExists : Exception
        {
            public PathExists(string path) : base("The library path " + path + " already exists.")
-            {}
+            { }
        }

        public class PathNotFound : Exception
        {
            public PathNotFound(string path) : base("The path " + path + " does not exist.")
-            {}
+            { }
        }

        public class LibraryNotFound : Exception
        {
            public LibraryNotFound(int LibraryId) : base("Library id " + LibraryId + " does not exist.")
-            {}
+            { }
        }

        public class CannotDeleteDefaultLibrary : Exception
        {
            public CannotDeleteDefaultLibrary() : base("Unable to delete the default library.")
-            {}
+            { }
        }

        public class CannotDeleteLibraryWhileScanIsActive : Exception
        {
            public CannotDeleteLibraryWhileScanIsActive() : base("Unable to delete library while a library scan is active. Wait for all scans to complete and try again")
-            {}
+            { }
        }

        // code
@@ -66,7 +66,7 @@ namespace gaseous_server
            {
                List<LibraryItem> libraryItems = new List<LibraryItem>();
                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-                string sql = "SELECT * FROM GameLibraries";
+                string sql = "SELECT * FROM GameLibraries ORDER BY `Name`;";
                DataTable data = db.ExecuteCMD(sql);
                foreach (DataRow row in data.Rows)
                {
@@ -129,7 +129,7 @@ namespace gaseous_server
            if (library.IsDefaultLibrary == false)
            {
                // check for active library scans
-                foreach(ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
+                foreach (ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
                {
                    if (
                        (item.ItemType == ProcessQueue.QueueItemType.LibraryScan && item.ItemState == ProcessQueue.QueueItemState.Running) ||
@@ -175,6 +175,24 @@ namespace gaseous_server
            }
        }

+        public static LibraryItem ScanLibrary(int LibraryId)
+        {
+            // add the library to scan to the queue
+            LibraryItem library = GetLibrary(LibraryId);
+            ImportGame.LibrariesToScan.Add(library);
+
+            // start the library scan if it's not already running
+            foreach (ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
+            {
+                if (item.ItemType == ProcessQueue.QueueItemType.LibraryScan && item.ItemState != ProcessQueue.QueueItemState.Running)
+                {
+                    item.ForceExecute();
+                }
+            }
+
+            return library;
+        }
+
        public class LibraryItem
        {
            public LibraryItem(int Id, string Name, string Path, long DefaultPlatformId, bool IsDefaultLibrary)
--- a/gaseous-server/Classes/ImportGames.cs
+++ b/gaseous-server/Classes/ImportGames.cs
@@ -16,48 +16,52 @@ using HasheousClient.Models;

 namespace gaseous_server.Classes
 {
-	public class ImportGame : QueueItemStatus
-	{
+    public class ImportGame : QueueItemStatus
+    {
        public void ProcessDirectory(string ImportPath)
        {
            if (Directory.Exists(ImportPath))
-			{
-				string[] importContents = Directory.GetFiles(ImportPath, "*.*", SearchOption.AllDirectories);
+            {
+                string[] importContents = Directory.GetFiles(ImportPath, "*.*", SearchOption.AllDirectories);

                Logging.Log(Logging.LogType.Information, "Import Games", "Found " + importContents.Length + " files to process in import directory: " + ImportPath);

-				// import files first
+                // import files first
                int importCount = 1;
-				foreach (string importContent in importContents) {
+                foreach (string importContent in importContents)
+                {
                    SetStatus(importCount, importContents.Length, "Importing file: " + importContent);

-					ImportGameFile(importContent, null);
+                    ImportGameFile(importContent, null);

                    importCount += 1;
-				}
+                }
                ClearStatus();

                DeleteOrphanedDirectories(ImportPath);
            }
-			else
-			{
-				Logging.Log(Logging.LogType.Critical, "Import Games", "The import directory " + ImportPath + " does not exist.");
-				throw new DirectoryNotFoundException("Invalid path: " + ImportPath);
-			}
+            else
+            {
+                Logging.Log(Logging.LogType.Critical, "Import Games", "The import directory " + ImportPath + " does not exist.");
+                throw new DirectoryNotFoundException("Invalid path: " + ImportPath);
+            }
        }

-        public void ImportGameFile(string GameFileImportPath, IGDB.Models.Platform? OverridePlatform)
-		{
+        public Dictionary<string, object> ImportGameFile(string GameFileImportPath, IGDB.Models.Platform? OverridePlatform)
+        {
+            Dictionary<string, object> RetVal = new Dictionary<string, object>();
+            RetVal.Add("path", Path.GetFileName(GameFileImportPath));
+
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql = "";
-			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            string sql = "";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();

            if (Common.SkippableFiles.Contains<string>(Path.GetFileName(GameFileImportPath), StringComparer.OrdinalIgnoreCase))
-			{ 
+            {
                Logging.Log(Logging.LogType.Debug, "Import Game", "Skipping item " + GameFileImportPath);
            }
-			else
-			{
+            else
+            {
                FileInfo fi = new FileInfo(GameFileImportPath);
                Common.hashObject hash = new Common.hashObject(GameFileImportPath);

@@ -66,6 +70,8 @@ namespace gaseous_server.Classes
                if (IsBios == null)
                {
                    // file is a rom
+                    RetVal.Add("type", "rom");
+
                    // check to make sure we don't already have this file imported
                    sql = "SELECT COUNT(Id) AS count FROM Games_Roms WHERE MD5=@md5 AND SHA1=@sha1";
                    dbDict.Add("md5", hash.md5hash);
@@ -93,6 +99,8 @@ namespace gaseous_server.Classes
                        {
                            Logging.Log(Logging.LogType.Warning, "Import Game", "  " + GameFileImportPath + " already in database - skipping import");
                        }
+
+                        RetVal.Add("status", "duplicate");
                    }
                    else
                    {
@@ -121,17 +129,27 @@ namespace gaseous_server.Classes
                        IGDB.Models.Game determinedGame = SearchForGame(discoveredSignature, discoveredSignature.Flags.IGDBPlatformId, true);

                        // add to database
-                        StoreROM(GameLibrary.GetDefaultLibrary, hash, determinedGame, determinedPlatform, discoveredSignature, GameFileImportPath);
+                        long RomId = StoreROM(GameLibrary.GetDefaultLibrary, hash, determinedGame, determinedPlatform, discoveredSignature, GameFileImportPath);
+
+                        // build return value
+                        RetVal.Add("romid", RomId);
+                        RetVal.Add("platform", determinedPlatform);
+                        RetVal.Add("game", determinedGame);
+                        RetVal.Add("signature", discoveredSignature);
+                        RetVal.Add("status", "imported");
                    }
                }
                else
                {
                    // file is a bios
-                    if (IsBios.WebEmulator != null)
+                    RetVal.Add("type", "bios");
+                    RetVal.Add("status", "notimported");
+
+                    foreach (Classes.Bios.BiosItem biosItem in Classes.Bios.GetBios())
                    {
-                        foreach (Classes.Bios.BiosItem biosItem in Classes.Bios.GetBios())
+                        if (biosItem.Available == false)
                        {
-                            if (biosItem.Available == false && biosItem.hash == hash.md5hash)
+                            if (biosItem.hash == hash.md5hash)
                            {
                                string biosPath = biosItem.biosPath.Replace(biosItem.filename, "");
                                if (!Directory.Exists(biosPath))
@@ -141,13 +159,27 @@ namespace gaseous_server.Classes

                                File.Move(GameFileImportPath, biosItem.biosPath, true);

-                                break;
+                                RetVal.Add("name", biosItem.filename);
+                                RetVal.Add("platform", Platforms.GetPlatform(biosItem.platformid, false, false));
+                                RetVal["status"] = "imported";
+
+                                return RetVal;
+                            }
+                        }
+                        else
+                        {
+                            if (biosItem.hash == hash.md5hash)
+                            {
+                                RetVal["status"] = "duplicate";
+                                return RetVal;
                            }
                        }
                    }
                }
-			}
-		}
+            }
+
+            return RetVal;
+        }

        public static IGDB.Models.Game SearchForGame(gaseous_server.Models.Signatures_Games Signature, long PlatformId, bool FullDownload)
        {
@@ -197,8 +229,10 @@ namespace gaseous_server.Classes
                        Logging.Log(Logging.LogType.Information, "Import Game", "  " + games.Length + " search results found");

                        // quite likely we've found sequels and alternate types
-                        foreach (Game game in games) {
-                            if (game.Name == SearchCandidate) {
+                        foreach (Game game in games)
+                        {
+                            if (game.Name == SearchCandidate)
+                            {
                                // found game title matches the search candidate
                                determinedGame = Metadata.Games.GetGame((long)games[0].Id, false, false, false);
                                Logging.Log(Logging.LogType.Information, "Import Game", "Found exact match!");
@@ -273,7 +307,8 @@ namespace gaseous_server.Classes

            // assumption: no games have () in their titles so we'll remove them
            int idx = GameName.IndexOf('(');
-            if (idx >= 0) {
+            if (idx >= 0)
+            {
                GameName = GameName.Substring(0, idx);
            }

@@ -304,10 +339,11 @@ namespace gaseous_server.Classes

            if (UpdateId == 0)
            {
-                sql = "INSERT INTO Games_Roms (PlatformId, GameId, Name, Size, CRC, MD5, SHA1, DevelopmentStatus, Attributes, RomType, RomTypeMedia, MediaLabel, Path, MetadataSource, MetadataGameName, MetadataVersion, LibraryId) VALUES (@platformid, @gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @Attributes, @romtype, @romtypemedia, @medialabel, @path, @metadatasource, @metadatagamename, @metadataversion, @libraryid); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
-            } else
+                sql = "INSERT INTO Games_Roms (PlatformId, GameId, Name, Size, CRC, MD5, SHA1, DevelopmentStatus, Attributes, RomType, RomTypeMedia, MediaLabel, Path, MetadataSource, MetadataGameName, MetadataVersion, LibraryId, RomDataVersion) VALUES (@platformid, @gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @Attributes, @romtype, @romtypemedia, @medialabel, @path, @metadatasource, @metadatagamename, @metadataversion, @libraryid, @romdataversion); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+            }
+            else
            {
-                sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid, Name=@name, Size=@size, DevelopmentStatus=@developmentstatus, Attributes=@Attributes, RomType=@romtype, RomTypeMedia=@romtypemedia, MediaLabel=@medialabel, MetadataSource=@metadatasource, MetadataGameName=@metadatagamename, MetadataVersion=@metadataversion WHERE Id=@id;";
+                sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid, Name=@name, Size=@size, DevelopmentStatus=@developmentstatus, Attributes=@Attributes, RomType=@romtype, RomTypeMedia=@romtypemedia, MediaLabel=@medialabel, MetadataSource=@metadatasource, MetadataGameName=@metadatagamename, MetadataVersion=@metadataversion, RomDataVersion=@romdataversion WHERE Id=@id;";
                dbDict.Add("id", UpdateId);
            }
            dbDict.Add("platformid", Common.ReturnValueIfNull(determinedPlatform.Id, 0));
@@ -322,6 +358,7 @@ namespace gaseous_server.Classes
            dbDict.Add("metadatagamename", discoveredSignature.Game.Name);
            dbDict.Add("metadataversion", 2);
            dbDict.Add("libraryid", library.Id);
+            dbDict.Add("romdataversion", 2);

            if (discoveredSignature.Rom.Attributes != null)
            {
@@ -348,7 +385,8 @@ namespace gaseous_server.Classes
            if (UpdateId == 0)
            {
                romId = (long)romInsert.Rows[0][0];
-            } else
+            }
+            else
            {
                romId = UpdateId;
            }
@@ -362,73 +400,73 @@ namespace gaseous_server.Classes
            return romId;
        }

-		public static string ComputeROMPath(long RomId)
-		{
-			Classes.Roms.GameRomItem rom = Classes.Roms.GetRom(RomId);
-
-			// get metadata
-			IGDB.Models.Platform platform = gaseous_server.Classes.Metadata.Platforms.GetPlatform(rom.PlatformId);
-			IGDB.Models.Game game = gaseous_server.Classes.Metadata.Games.GetGame(rom.GameId, false, false, false);
-
-			// build path
-			string platformSlug = "Unknown Platform";
-			if (platform != null)
-			{
-				platformSlug = platform.Slug;
-			}
-			string gameSlug = "Unknown Title";
-			if (game != null)
-			{
-				gameSlug = game.Slug;
-			}
-			string DestinationPath = Path.Combine(GameLibrary.GetDefaultLibrary.Path, gameSlug, platformSlug);
-			if (!Directory.Exists(DestinationPath))
-			{
-				Directory.CreateDirectory(DestinationPath);
-			}
-
-			string DestinationPathName = Path.Combine(DestinationPath, rom.Name);
-
-			return DestinationPathName;
-		}
-
-		public static bool MoveGameFile(long RomId)
-		{
+        public static string ComputeROMPath(long RomId)
+        {
            Classes.Roms.GameRomItem rom = Classes.Roms.GetRom(RomId);
-			string romPath = rom.Path;
+
+            // get metadata
+            IGDB.Models.Platform platform = gaseous_server.Classes.Metadata.Platforms.GetPlatform(rom.PlatformId);
+            IGDB.Models.Game game = gaseous_server.Classes.Metadata.Games.GetGame(rom.GameId, false, false, false);
+
+            // build path
+            string platformSlug = "Unknown Platform";
+            if (platform != null)
+            {
+                platformSlug = platform.Slug;
+            }
+            string gameSlug = "Unknown Title";
+            if (game != null)
+            {
+                gameSlug = game.Slug;
+            }
+            string DestinationPath = Path.Combine(GameLibrary.GetDefaultLibrary.Path, gameSlug, platformSlug);
+            if (!Directory.Exists(DestinationPath))
+            {
+                Directory.CreateDirectory(DestinationPath);
+            }
+
+            string DestinationPathName = Path.Combine(DestinationPath, rom.Name);
+
+            return DestinationPathName;
+        }
+
+        public static bool MoveGameFile(long RomId)
+        {
+            Classes.Roms.GameRomItem rom = Classes.Roms.GetRom(RomId);
+            string romPath = rom.Path;

            if (File.Exists(romPath))
            {
                string DestinationPath = ComputeROMPath(RomId);

-				if (romPath == DestinationPath)
-				{
-					Logging.Log(Logging.LogType.Debug, "Move Game ROM", "Destination path is the same as the current path - aborting");
+                if (romPath == DestinationPath)
+                {
+                    Logging.Log(Logging.LogType.Debug, "Move Game ROM", "Destination path is the same as the current path - aborting");
                    return true;
-				}
-				else
-				{
-					Logging.Log(Logging.LogType.Information, "Move Game ROM", "Moving " + romPath + " to " + DestinationPath);
-					if (File.Exists(DestinationPath))
-					{
-						Logging.Log(Logging.LogType.Information, "Move Game ROM", "A file with the same name exists at the destination - aborting");
+                }
+                else
+                {
+                    Logging.Log(Logging.LogType.Information, "Move Game ROM", "Moving " + romPath + " to " + DestinationPath);
+                    if (File.Exists(DestinationPath))
+                    {
+                        Logging.Log(Logging.LogType.Information, "Move Game ROM", "A file with the same name exists at the destination - aborting");
                        return false;
-					}
-					else
-					{
-						File.Move(romPath, DestinationPath);
+                    }
+                    else
+                    {
+                        File.Move(romPath, DestinationPath);

-						// update the db
-						Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-						string sql = "UPDATE Games_Roms SET Path=@path WHERE Id=@id";
-						Dictionary<string, object> dbDict = new Dictionary<string, object>();
-						dbDict.Add("id", RomId);
-						dbDict.Add("path", DestinationPath);
-						db.ExecuteCMD(sql, dbDict);
+                        // update the db
+                        Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                        string sql = "UPDATE Games_Roms SET Path=@path WHERE Id=@id";
+                        Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                        dbDict.Add("id", RomId);
+                        dbDict.Add("path", DestinationPath);
+                        db.ExecuteCMD(sql, dbDict);

                        return true;
-					}
-				}
+                    }
+                }
            }
            else
            {
@@ -437,8 +475,8 @@ namespace gaseous_server.Classes
            }
        }

-		public void OrganiseLibrary()
-		{
+        public void OrganiseLibrary()
+        {
            Logging.Log(Logging.LogType.Information, "Organise Library", "Starting default library organisation");

            GameLibrary.LibraryItem library = GameLibrary.GetDefaultLibrary;
@@ -451,19 +489,19 @@ namespace gaseous_server.Classes
            DataTable romDT = db.ExecuteCMD(sql, dbDict);

            if (romDT.Rows.Count > 0)
-			{
-				for (int i = 0; i < romDT.Rows.Count; i++)
-				{
+            {
+                for (int i = 0; i < romDT.Rows.Count; i++)
+                {
                    SetStatus(i, romDT.Rows.Count, "Processing file " + romDT.Rows[i]["name"]);
-					Logging.Log(Logging.LogType.Information, "Organise Library", "(" + i + "/" + romDT.Rows.Count + ") Processing ROM " + romDT.Rows[i]["name"]);
+                    Logging.Log(Logging.LogType.Information, "Organise Library", "(" + i + "/" + romDT.Rows.Count + ") Processing ROM " + romDT.Rows[i]["name"]);
                    long RomId = (long)romDT.Rows[i]["id"];
-					MoveGameFile(RomId);
-				}
-			}
+                    MoveGameFile(RomId);
+                }
+            }
            ClearStatus();

-			// clean up empty directories
-			DeleteOrphanedDirectories(GameLibrary.GetDefaultLibrary.Path);
+            // clean up empty directories
+            DeleteOrphanedDirectories(GameLibrary.GetDefaultLibrary.Path);

            Logging.Log(Logging.LogType.Information, "Organise Library", "Finsihed default library organisation");
        }
@@ -485,61 +523,82 @@ namespace gaseous_server.Classes
            }
        }

-        public void LibraryScan(GameLibrary.LibraryItem? singleLibrary = null)
+        public static List<GameLibrary.LibraryItem> LibrariesToScan = new List<GameLibrary.LibraryItem>();
+        public void LibraryScan()
        {
            int maxWorkers = Config.MetadataConfiguration.MaxLibraryScanWorkers;

-            List<GameLibrary.LibraryItem> libraries = new List<GameLibrary.LibraryItem>();
-            if (singleLibrary == null)
+            if (LibrariesToScan.Count == 0)
            {
-                libraries.AddRange(GameLibrary.GetLibraries);
-            }
-            else
-            {
-                libraries.Add(singleLibrary);
+                LibrariesToScan.AddRange(GameLibrary.GetLibraries);
            }

            // setup background tasks for each library
-            foreach (GameLibrary.LibraryItem library in libraries)
+            do
            {
-                Logging.Log(Logging.LogType.Information, "Library Scan", "Starting worker process for library " + library.Name);
-                ProcessQueue.QueueItem queue = new ProcessQueue.QueueItem(
-                    ProcessQueue.QueueItemType.LibraryScanWorker,
-                    1,
-                    new List<ProcessQueue.QueueItemType>
-                    {
-                        ProcessQueue.QueueItemType.OrganiseLibrary,
-                        ProcessQueue.QueueItemType.Rematcher
-                    },
-                    false,
-                    true);
-                queue.Options = library;
-                queue.ForceExecute();
+                Logging.Log(Logging.LogType.Information, "Library Scan", "Library scan queue size: " + LibrariesToScan.Count);

-                ProcessQueue.QueueItems.Add(queue);
+                GameLibrary.LibraryItem library = LibrariesToScan[0];
+                LibrariesToScan.RemoveAt(0);

-                // check number of running tasks is less than maxWorkers
-                bool allowContinue;
-                do
+                // check if library is already being scanned
+                bool libraryAlreadyScanning = false;
+                List<ProcessQueue.QueueItem> ProcessQueueItems = new List<ProcessQueue.QueueItem>();
+                ProcessQueueItems.AddRange(ProcessQueue.QueueItems);
+                foreach (ProcessQueue.QueueItem item in ProcessQueueItems)
                {
-                    allowContinue = true;
-                    int currentWorkerCount = 0;
-                    List<ProcessQueue.QueueItem> queueItems = new List<ProcessQueue.QueueItem>();
-                    queueItems.AddRange(ProcessQueue.QueueItems);
-                    foreach (ProcessQueue.QueueItem item in queueItems)
+                    if (item.ItemType == ProcessQueue.QueueItemType.LibraryScanWorker)
                    {
-                        if (item.ItemType == ProcessQueue.QueueItemType.LibraryScanWorker)
+                        if (((GameLibrary.LibraryItem)item.Options).Id == library.Id)
                        {
-                            currentWorkerCount += 1;
+                            libraryAlreadyScanning = true;
                        }
                    }
-                    if (currentWorkerCount >= maxWorkers)
+                }
+
+                if (libraryAlreadyScanning == false)
+                {
+                    Logging.Log(Logging.LogType.Information, "Library Scan", "Starting worker process for library " + library.Name);
+                    ProcessQueue.QueueItem queue = new ProcessQueue.QueueItem(
+                        ProcessQueue.QueueItemType.LibraryScanWorker,
+                        1,
+                        new List<ProcessQueue.QueueItemType>
+                        {
+                        ProcessQueue.QueueItemType.OrganiseLibrary,
+                        ProcessQueue.QueueItemType.Rematcher
+                        },
+                        false,
+                        true)
                    {
-                        allowContinue = false;
-                        Thread.Sleep(60000);
-                    }
-                } while (allowContinue == false);
-            }
+                        Options = library
+                    };
+                    queue.ForceExecute();
+
+                    ProcessQueue.QueueItems.Add(queue);
+
+                    // check number of running tasks is less than maxWorkers
+                    bool allowContinue;
+                    do
+                    {
+                        allowContinue = true;
+                        int currentWorkerCount = 0;
+                        List<ProcessQueue.QueueItem> LibraryScan_QueueItems = new List<ProcessQueue.QueueItem>();
+                        LibraryScan_QueueItems.AddRange(ProcessQueue.QueueItems);
+                        foreach (ProcessQueue.QueueItem item in LibraryScan_QueueItems)
+                        {
+                            if (item.ItemType == ProcessQueue.QueueItemType.LibraryScanWorker)
+                            {
+                                currentWorkerCount += 1;
+                            }
+                        }
+                        if (currentWorkerCount >= maxWorkers)
+                        {
+                            allowContinue = false;
+                            Thread.Sleep(60000);
+                        }
+                    } while (allowContinue == false);
+                }
+            } while (LibrariesToScan.Count > 0);

            bool WorkersStillWorking;
            do
@@ -559,6 +618,12 @@ namespace gaseous_server.Classes
            } while (WorkersStillWorking == true);

            Logging.Log(Logging.LogType.Information, "Library Scan", "Library scan complete. All workers stopped");
+
+            if (LibrariesToScan.Count > 0)
+            {
+                Logging.Log(Logging.LogType.Information, "Library Scan", "There are still libraries to scan. Restarting scan process");
+                LibraryScan();
+            }
        }

        public void LibrarySpecificScan(GameLibrary.LibraryItem library)
@@ -645,7 +710,7 @@ namespace gaseous_server.Classes
                            long PlatformId;
                            IGDB.Models.Platform determinedPlatform;

-                            if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0 )
+                            if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0)
                            {
                                // no platform discovered in the signature
                                PlatformId = library.DefaultPlatformId;
@@ -771,7 +836,7 @@ namespace gaseous_server.Classes
                    long PlatformId;
                    IGDB.Models.Platform determinedPlatform;

-                    if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0 )
+                    if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0)
                    {
                        // no platform discovered in the signature
                        PlatformId = library.DefaultPlatformId;
--- a/gaseous-server/Classes/Logging.cs
+++ b/gaseous-server/Classes/Logging.cs
@@ -3,10 +3,11 @@ using System.Data;
 using System.Diagnostics;
 using System.Reflection;
 using System.Reflection.Metadata.Ecma335;
+using Microsoft.VisualStudio.Web.CodeGenerators.Mvc.Templates.BlazorIdentity.Pages;
 namespace gaseous_server.Classes
 {
-	public class Logging
-	{
+    public class Logging
+    {
        private static DateTime lastDiskRetentionSweep = DateTime.UtcNow;
        public static bool WriteToDiskOnly { get; set; } = false;

@@ -21,8 +22,13 @@ namespace gaseous_server.Classes
                ExceptionValue = Common.ReturnValueIfNull(ExceptionValue, "").ToString()
            };

+            _ = Task.Run(() => WriteLogAsync(logItem, LogToDiskOnly));
+        }
+
+        static async Task WriteLogAsync(LogItem logItem, bool LogToDiskOnly)
+        {
            bool AllowWrite = false;
-            if (EventType == LogType.Debug)
+            if (logItem.EventType == LogType.Debug)
            {
                if (Config.LoggingConfiguration.DebugLogging == true)
                {
@@ -42,26 +48,32 @@ namespace gaseous_server.Classes
                {
                    TraceOutput += Environment.NewLine + logItem.ExceptionValue.ToString();
                }
-                switch(logItem.EventType) {
+                string consoleColour = "";
+                switch (logItem.EventType)
+                {
                    case LogType.Information:
-                        Console.ForegroundColor = ConsoleColor.Blue;
+                        // Console.ForegroundColor = ConsoleColor.Blue;
+                        consoleColour = "\u001b[1;34m]";
                        break;

                    case LogType.Warning:
-                        Console.ForegroundColor = ConsoleColor.Yellow;
+                        // Console.ForegroundColor = ConsoleColor.Yellow;
+                        consoleColour = "\u001b[1;33m]";
                        break;

                    case LogType.Critical:
-                        Console.ForegroundColor = ConsoleColor.Red;
+                        // Console.ForegroundColor = ConsoleColor.Red;
+                        consoleColour = "\u001b[1;31m]";
                        break;

                    case LogType.Debug:
-                        Console.ForegroundColor = ConsoleColor.Magenta;
+                        // Console.ForegroundColor = ConsoleColor.Magenta;
+                        consoleColour = "\u001b[1;36m]";
                        break;

                }
-                Console.WriteLine(TraceOutput);
-                Console.ResetColor();
+                Console.WriteLine(consoleColour + TraceOutput);
+                // Console.ResetColor();

                if (WriteToDiskOnly == true)
                {
--- a/gaseous-server/Classes/Maintenance.cs
+++ b/gaseous-server/Classes/Maintenance.cs
@@ -5,7 +5,7 @@ using Microsoft.VisualStudio.Web.CodeGeneration;

 namespace gaseous_server.Classes
 {
-	public class Maintenance : QueueItemStatus
+    public class Maintenance : QueueItemStatus
    {
        const int MaxFileAge = 30;

@@ -16,6 +16,7 @@ namespace gaseous_server.Classes
            Dictionary<string, object> dbDict = new Dictionary<string, object>();

            // remove any entries from the library that have an invalid id
+            Logging.Log(Logging.LogType.Information, "Maintenance", "Removing any entries from the library that have an invalid id");
            string LibraryWhereClause = "";
            foreach (GameLibrary.LibraryItem library in GameLibrary.GetLibraries)
            {
@@ -33,9 +34,29 @@ namespace gaseous_server.Classes
            }

            // delete old logs
-            sql = "DELETE FROM ServerLogs WHERE EventTime < @EventRetentionDate;";
+            Logging.Log(Logging.LogType.Information, "Maintenance", "Removing logs older than " + Config.LoggingConfiguration.LogRetention + " days");
+            long deletedCount = 1;
+            long deletedEventCount = 0;
+            long maxLoops = 10000;
+            sql = "DELETE FROM ServerLogs WHERE EventTime < @EventRetentionDate LIMIT 1000; SELECT ROW_COUNT() AS Count;";
            dbDict.Add("EventRetentionDate", DateTime.UtcNow.AddDays(Config.LoggingConfiguration.LogRetention * -1));
-            db.ExecuteCMD(sql, dbDict);
+            while (deletedCount > 0)
+            {
+                DataTable deletedCountTable = db.ExecuteCMD(sql, dbDict);
+                deletedCount = (long)deletedCountTable.Rows[0][0];
+                deletedEventCount += deletedCount;
+
+                Logging.Log(Logging.LogType.Information, "Maintenance", "Deleted " + deletedCount + " log entries");
+
+                // check if we've hit the limit
+                maxLoops -= 1;
+                if (maxLoops <= 0)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Maintenance", "Hit the maximum number of loops for deleting logs. Stopping.");
+                    break;
+                }
+            }
+            Logging.Log(Logging.LogType.Information, "Maintenance", "Deleted " + deletedEventCount + " log entries");

            // delete files and directories older than 7 days in PathsToClean
            List<string> PathsToClean = new List<string>();
@@ -87,7 +108,7 @@ namespace gaseous_server.Classes
                SetStatus(StatusCounter, tables.Rows.Count, "Optimising table " + row[0].ToString());

                sql = "OPTIMIZE TABLE " + row[0].ToString();
-                DataTable response = db.ExecuteCMD(sql);
+                DataTable response = db.ExecuteCMD(sql, new Dictionary<string, object>(), 240);
                foreach (DataRow responseRow in response.Rows)
                {
                    string retVal = "";
--- a/gaseous-server/Classes/Metadata/AgeGroups.cs
+++ b/gaseous-server/Classes/Metadata/AgeGroups.cs
@@ -216,44 +216,48 @@ namespace gaseous_server.Classes.Metadata
            }
        }

-        readonly static AgeGroupItem Adult_Item = new AgeGroupItem{
-            ACB         = new List<AgeRatingTitle>{ AgeRatingTitle.ACB_R18, AgeRatingTitle.ACB_RC },
-            CERO        = new List<AgeRatingTitle>{ AgeRatingTitle.CERO_Z },
-            CLASS_IND   = new List<AgeRatingTitle>{ AgeRatingTitle.CLASS_IND_Eighteen },
-            ESRB        = new List<AgeRatingTitle>{ AgeRatingTitle.RP, AgeRatingTitle.AO },
-            GRAC        = new List<AgeRatingTitle>{ AgeRatingTitle.GRAC_Eighteen },
-            PEGI        = new List<AgeRatingTitle>{ AgeRatingTitle.Eighteen},
-            USK         = new List<AgeRatingTitle>{ AgeRatingTitle.USK_18}
+        readonly static AgeGroupItem Adult_Item = new AgeGroupItem
+        {
+            ACB = new List<AgeRatingTitle> { AgeRatingTitle.ACB_R18, AgeRatingTitle.ACB_RC },
+            CERO = new List<AgeRatingTitle> { AgeRatingTitle.CERO_Z },
+            CLASS_IND = new List<AgeRatingTitle> { AgeRatingTitle.CLASS_IND_Eighteen },
+            ESRB = new List<AgeRatingTitle> { AgeRatingTitle.RP, AgeRatingTitle.AO },
+            GRAC = new List<AgeRatingTitle> { AgeRatingTitle.GRAC_Eighteen },
+            PEGI = new List<AgeRatingTitle> { AgeRatingTitle.Eighteen },
+            USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_18 }
        };

-        readonly static AgeGroupItem Mature_Item = new AgeGroupItem{
-            ACB         = new List<AgeRatingTitle>{ AgeRatingTitle.ACB_M, AgeRatingTitle.ACB_MA15 },
-            CERO        = new List<AgeRatingTitle>{ AgeRatingTitle.CERO_C, AgeRatingTitle.CERO_D },
-            CLASS_IND   = new List<AgeRatingTitle>{ AgeRatingTitle.CLASS_IND_Sixteen },
-            ESRB        = new List<AgeRatingTitle>{ AgeRatingTitle.M },
-            GRAC        = new List<AgeRatingTitle>{ AgeRatingTitle.GRAC_Fifteen },
-            PEGI        = new List<AgeRatingTitle>{ AgeRatingTitle.Sixteen},
-            USK         = new List<AgeRatingTitle>{ AgeRatingTitle.USK_16}
+        readonly static AgeGroupItem Mature_Item = new AgeGroupItem
+        {
+            ACB = new List<AgeRatingTitle> { AgeRatingTitle.ACB_M, AgeRatingTitle.ACB_MA15 },
+            CERO = new List<AgeRatingTitle> { AgeRatingTitle.CERO_C, AgeRatingTitle.CERO_D },
+            CLASS_IND = new List<AgeRatingTitle> { AgeRatingTitle.CLASS_IND_Sixteen },
+            ESRB = new List<AgeRatingTitle> { AgeRatingTitle.M },
+            GRAC = new List<AgeRatingTitle> { AgeRatingTitle.GRAC_Fifteen },
+            PEGI = new List<AgeRatingTitle> { AgeRatingTitle.Sixteen },
+            USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_16 }
        };

-        readonly static AgeGroupItem Teen_Item = new AgeGroupItem{
-            ACB         = new List<AgeRatingTitle>{ AgeRatingTitle.ACB_PG },
-            CERO        = new List<AgeRatingTitle>{ AgeRatingTitle.CERO_B },
-            CLASS_IND   = new List<AgeRatingTitle>{ AgeRatingTitle.CLASS_IND_Twelve, AgeRatingTitle.CLASS_IND_Fourteen },
-            ESRB        = new List<AgeRatingTitle>{ AgeRatingTitle.T },
-            GRAC        = new List<AgeRatingTitle>{ AgeRatingTitle.GRAC_Twelve },
-            PEGI        = new List<AgeRatingTitle>{ AgeRatingTitle.Twelve},
-            USK         = new List<AgeRatingTitle>{ AgeRatingTitle.USK_12}
+        readonly static AgeGroupItem Teen_Item = new AgeGroupItem
+        {
+            ACB = new List<AgeRatingTitle> { AgeRatingTitle.ACB_PG },
+            CERO = new List<AgeRatingTitle> { AgeRatingTitle.CERO_B },
+            CLASS_IND = new List<AgeRatingTitle> { AgeRatingTitle.CLASS_IND_Twelve, AgeRatingTitle.CLASS_IND_Fourteen },
+            ESRB = new List<AgeRatingTitle> { AgeRatingTitle.T },
+            GRAC = new List<AgeRatingTitle> { AgeRatingTitle.GRAC_Twelve },
+            PEGI = new List<AgeRatingTitle> { AgeRatingTitle.Twelve },
+            USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_12 }
        };

-        readonly static AgeGroupItem Child_Item = new AgeGroupItem{
-            ACB         = new List<AgeRatingTitle>{ AgeRatingTitle.ACB_G },
-            CERO        = new List<AgeRatingTitle>{ AgeRatingTitle.CERO_A },
-            CLASS_IND   = new List<AgeRatingTitle>{ AgeRatingTitle.CLASS_IND_L, AgeRatingTitle.CLASS_IND_Ten },
-            ESRB        = new List<AgeRatingTitle>{ AgeRatingTitle.E, AgeRatingTitle.E10 },
-            GRAC        = new List<AgeRatingTitle>{ AgeRatingTitle.GRAC_All },
-            PEGI        = new List<AgeRatingTitle>{ AgeRatingTitle.Three, AgeRatingTitle.Seven},
-            USK         = new List<AgeRatingTitle>{ AgeRatingTitle.USK_0, AgeRatingTitle.USK_6}
+        readonly static AgeGroupItem Child_Item = new AgeGroupItem
+        {
+            ACB = new List<AgeRatingTitle> { AgeRatingTitle.ACB_G },
+            CERO = new List<AgeRatingTitle> { AgeRatingTitle.CERO_A },
+            CLASS_IND = new List<AgeRatingTitle> { AgeRatingTitle.CLASS_IND_L, AgeRatingTitle.CLASS_IND_Ten },
+            ESRB = new List<AgeRatingTitle> { AgeRatingTitle.EC, AgeRatingTitle.E, AgeRatingTitle.E10 },
+            GRAC = new List<AgeRatingTitle> { AgeRatingTitle.GRAC_All },
+            PEGI = new List<AgeRatingTitle> { AgeRatingTitle.Three, AgeRatingTitle.Seven },
+            USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_0, AgeRatingTitle.USK_6 }
        };

        public class AgeGroupItem
--- a/gaseous-server/Classes/Metadata/Artworks.cs
+++ b/gaseous-server/Classes/Metadata/Artworks.cs
@@ -5,7 +5,7 @@ using IGDB.Models;

 namespace gaseous_server.Classes.Metadata
 {
-	public class Artworks
+    public class Artworks
    {
        const string fieldList = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;";

@@ -74,7 +74,13 @@ namespace gaseous_server.Classes.Metadata
                    {
                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
+
+                        // check if old value is different from the new value - only download if it's different
+                        Artwork oldImage = Storage.GetCacheValue<Artwork>(returnValue, "id", (long)searchValue);
+                        if (oldImage.ImageId != returnValue.ImageId)
+                        {
+                            forceImageDownload = true;
+                        }
                    }
                    catch (Exception ex)
                    {
@@ -120,6 +126,6 @@ namespace gaseous_server.Classes.Metadata

            return result;
        }
-	}
+    }
 }

--- a/gaseous-server/Classes/Metadata/Communications.cs
+++ b/gaseous-server/Classes/Metadata/Communications.cs
@@ -195,6 +195,7 @@ namespace gaseous_server.Classes.Metadata
                if (InRateLimitAvoidanceMode == true)
                {
                    // sleep for a moment to help avoid hitting the rate limiter
+                    Logging.Log(Logging.LogType.Information, "API Connection: Endpoint:" + Endpoint, "IGDB rate limit hit. Pausing API communications for " + RateLimitAvoidanceWait + " milliseconds to avoid rate limiter.");
                    Thread.Sleep(RateLimitAvoidanceWait);
                }

@@ -245,7 +246,7 @@ namespace gaseous_server.Classes.Metadata
                        throw;
                }
            }
-            catch(Exception ex)
+            catch (Exception ex)
            {
                Logging.Log(Logging.LogType.Warning, "API Connection", "Exception when accessing endpoint " + Endpoint, ex);
                throw;
@@ -393,6 +394,7 @@ namespace gaseous_server.Classes.Metadata
                    if (InRateLimitAvoidanceMode == true)
                    {
                        // sleep for a moment to help avoid hitting the rate limiter
+                        Logging.Log(Logging.LogType.Information, "API Connection: Fetch Image", "IGDB rate limit hit. Pausing API communications for " + RateLimitAvoidanceWait + " milliseconds to avoid rate limiter.");
                        Thread.Sleep(RateLimitAvoidanceWait);
                    }

--- a/gaseous-server/Classes/Metadata/CompanyLogos.cs
+++ b/gaseous-server/Classes/Metadata/CompanyLogos.cs
@@ -76,7 +76,13 @@ namespace gaseous_server.Classes.Metadata
                    {
                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
+
+                        // check if old value is different from the new value - only download if it's different
+                        CompanyLogo oldImage = Storage.GetCacheValue<CompanyLogo>(returnValue, "id", (long)searchValue);
+                        if (oldImage.ImageId != returnValue.ImageId)
+                        {
+                            forceImageDownload = true;
+                        }
                    }
                    catch (Exception ex)
                    {
--- a/gaseous-server/Classes/Metadata/Covers.cs
+++ b/gaseous-server/Classes/Metadata/Covers.cs
@@ -7,7 +7,7 @@ using Microsoft.CodeAnalysis.Elfie.Model.Strings;

 namespace gaseous_server.Classes.Metadata
 {
-	public class Covers
+    public class Covers
    {
        const string fieldList = "fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;";

@@ -76,7 +76,13 @@ namespace gaseous_server.Classes.Metadata
                    {
                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
+
+                        // check if old value is different from the new value - only download if it's different
+                        Cover oldCover = Storage.GetCacheValue<Cover>(returnValue, "id", (long)searchValue);
+                        if (oldCover.ImageId != returnValue.ImageId)
+                        {
+                            forceImageDownload = true;
+                        }
                    }
                    catch (Exception ex)
                    {
@@ -135,6 +141,6 @@ namespace gaseous_server.Classes.Metadata

            return result;
        }
-	}
+    }
 }

--- a/gaseous-server/Classes/Metadata/Games.cs
+++ b/gaseous-server/Classes/Metadata/Games.cs
@@ -1,13 +1,14 @@
 using System;
 using System.Data;
+using gaseous_server.Models;
 using IGDB;
 using IGDB.Models;

 namespace gaseous_server.Classes.Metadata
 {
-	public class Games
-	{
-        const string fieldList = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collection,collections,cover,created_at,dlcs,expanded_games,expansions,external_games,first_release_date,follows,forks,franchise,franchises,game_engines,game_localizations,game_modes,genres,hypes,involved_companies,keywords,language_supports,multiplayer_modes,name,parent_game,platforms,player_perspectives,ports,rating,rating_count,release_dates,remakes,remasters,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;";
+    public class Games
+    {
+        const string fieldList = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collections,cover,created_at,dlcs,expanded_games,expansions,external_games,first_release_date,follows,forks,franchise,franchises,game_engines,game_localizations,game_modes,genres,hypes,involved_companies,keywords,language_supports,multiplayer_modes,name,parent_game,platforms,player_perspectives,ports,rating,rating_count,release_dates,remakes,remasters,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;";

        public Games()
        {
@@ -17,7 +18,7 @@ namespace gaseous_server.Classes.Metadata
        public class InvalidGameId : Exception
        {
            public InvalidGameId(long Id) : base("Unable to find Game by id " + Id)
-            {}
+            { }
        }

        public static Game? GetGame(long Id, bool getAllMetadata, bool followSubGames, bool forceRefresh)
@@ -78,15 +79,17 @@ namespace gaseous_server.Classes.Metadata
                if (cacheStatus == Storage.CacheStatus.Current) { cacheStatus = Storage.CacheStatus.Expired; }
            }

-            // set up where clause
            string WhereClause = "";
+            string searchField = "";
            switch (searchUsing)
            {
                case SearchUsing.id:
                    WhereClause = "where id = " + searchValue;
+                    searchField = "id";
                    break;
                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
+                    WhereClause = "where slug = \"" + searchValue + "\"";
+                    searchField = "slug";
                    break;
                default:
                    throw new Exception("Invalid search type");
@@ -110,11 +113,11 @@ namespace gaseous_server.Classes.Metadata
                    catch (Exception ex)
                    {
                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Game>(returnValue, "id", (long)searchValue);
+                        returnValue = Storage.GetCacheValue<Game>(returnValue, searchField, searchValue);
                    }
                    return returnValue;
                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Game>(returnValue, "id", (long)searchValue);
+                    returnValue = Storage.GetCacheValue<Game>(returnValue, searchField, searchValue);
                    UpdateSubClasses(returnValue, false, false, false);
                    return returnValue;
                default:
@@ -125,17 +128,17 @@ namespace gaseous_server.Classes.Metadata
        private static void UpdateSubClasses(Game Game, bool getAllMetadata, bool followSubGames, bool forceRefresh)
        {
            // required metadata
-            if (Game.Cover != null)
-            {
-                try
-                {
-                    Cover GameCover = Covers.GetCover(Game.Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch cover artwork.", ex);
-                }
-            }
+            // if (Game.Cover != null)
+            // {
+            //     try
+            //     {
+            //         Cover GameCover = Covers.GetCover(Game.Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
+            //     }
+            //     catch (Exception ex)
+            //     {
+            //         Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch cover artwork.", ex);
+            //     }
+            // }

            if (Game.Genres != null)
            {
@@ -285,7 +288,7 @@ namespace gaseous_server.Classes.Metadata
                    {
                        try
                        {
-                        Screenshot GameScreenshot = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
+                            Screenshot GameScreenshot = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
                        }
                        catch (Exception ex)
                        {
@@ -347,7 +350,7 @@ namespace gaseous_server.Classes.Metadata

            // get missing metadata from parent if this is a port
            if (result.Category == Category.Port)
-                {
+            {
                if (result.Summary == null)
                {
                    if (result.ParentGame != null)
@@ -439,7 +442,8 @@ namespace gaseous_server.Classes.Metadata
                DataTable data = db.ExecuteCMD(sql, dbDict);
                foreach (DataRow row in data.Rows)
                {
-                    Game game = new Game{
+                    Game game = new Game
+                    {
                        Id = (long)row["Id"],
                        Name = (string)Common.ReturnValueIfNull(row["Name"], ""),
                        Slug = (string)Common.ReturnValueIfNull(row["Slug"], ""),
@@ -501,24 +505,155 @@ namespace gaseous_server.Classes.Metadata
            }
        }

-        public static List<KeyValuePair<long, string>> GetAvailablePlatforms(long GameId)
+        public static List<AvailablePlatformItem> GetAvailablePlatforms(string UserId, long GameId)
        {
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT DISTINCT Games_Roms.PlatformId, Platform.`Name` FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id WHERE Games_Roms.GameId = @gameid ORDER BY Platform.`Name`;";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("gameid", GameId);
+            string sql = @"
+SELECT DISTINCT
+    Games_Roms.GameId,
+    Games_Roms.PlatformId,
+    Platform.`Name`,
+    User_RecentPlayedRoms.UserId AS MostRecentUserId,
+    User_RecentPlayedRoms.RomId AS MostRecentRomId,
+    CASE User_RecentPlayedRoms.IsMediaGroup
+        WHEN 0 THEN GMR.`Name`
+        WHEN 1 THEN 'Media Group'
+        ELSE NULL
+    END AS `MostRecentRomName`,
+    User_RecentPlayedRoms.IsMediaGroup AS MostRecentRomIsMediaGroup,
+    User_GameFavouriteRoms.UserId AS FavouriteUserId,
+    User_GameFavouriteRoms.RomId AS FavouriteRomId,
+    CASE User_GameFavouriteRoms.IsMediaGroup
+        WHEN 0 THEN GFV.`Name`
+        WHEN 1 THEN 'Media Group'
+        ELSE NULL
+    END AS `FavouriteRomName`,
+    User_GameFavouriteRoms.IsMediaGroup AS FavouriteRomIsMediaGroup
+FROM
+    Games_Roms
+        LEFT JOIN
+    Platform ON Games_Roms.PlatformId = Platform.Id
+        LEFT JOIN
+    User_RecentPlayedRoms ON User_RecentPlayedRoms.UserId = @userid
+        AND User_RecentPlayedRoms.GameId = Games_Roms.GameId
+        AND User_RecentPlayedRoms.PlatformId = Games_Roms.PlatformId
+        LEFT JOIN
+    User_GameFavouriteRoms ON User_GameFavouriteRoms.UserId = @userid
+        AND User_GameFavouriteRoms.GameId = Games_Roms.GameId
+        AND User_GameFavouriteRoms.PlatformId = Games_Roms.PlatformId
+        LEFT JOIN
+    Games_Roms AS GMR ON GMR.Id = User_RecentPlayedRoms.RomId
+        LEFT JOIN
+    Games_Roms AS GFV ON GFV.Id = User_GameFavouriteRoms.RomId
+WHERE
+    Games_Roms.GameId = @gameid
+ORDER BY Platform.`Name`;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "gameid", GameId },
+                { "userid", UserId }
+            };
            DataTable data = db.ExecuteCMD(sql, dbDict);

-            List<KeyValuePair<long, string>> platforms = new List<KeyValuePair<long, string>>();
+            PlatformMapping platformMapping = new PlatformMapping();
+            List<AvailablePlatformItem> platforms = new List<AvailablePlatformItem>();
            foreach (DataRow row in data.Rows)
            {
-                KeyValuePair<long, string> valuePair = new KeyValuePair<long, string>((long)row["PlatformId"], (string)row["Name"]);
-				platforms.Add(valuePair);
+                IGDB.Models.Platform platform = Platforms.GetPlatform((long)row["PlatformId"]);
+                PlatformMapping.UserEmulatorConfiguration? emulatorConfiguration = platformMapping.GetUserEmulator(UserId, GameId, (long)platform.Id);
+
+                if (emulatorConfiguration == null)
+                {
+                    if (platform.Id != 0)
+                    {
+                        Models.PlatformMapping.PlatformMapItem platformMap = PlatformMapping.GetPlatformMap((long)platform.Id);
+                        emulatorConfiguration = new PlatformMapping.UserEmulatorConfiguration
+                        {
+                            EmulatorType = platformMap.WebEmulator.Type,
+                            Core = platformMap.WebEmulator.Core,
+                            EnableBIOSFiles = platformMap.EnabledBIOSHashes
+                        };
+                    }
+                }
+
+                long? LastPlayedRomId = null;
+                bool? LastPlayedIsMediagroup = false;
+                string? LastPlayedRomName = null;
+                if (row["MostRecentRomId"] != DBNull.Value)
+                {
+                    LastPlayedRomId = (long?)row["MostRecentRomId"];
+                    LastPlayedIsMediagroup = (bool)row["MostRecentRomIsMediaGroup"];
+                    LastPlayedRomName = (string)row["MostRecentRomName"];
+                }
+
+                long? FavouriteRomId = null;
+                bool? FavouriteRomIsMediagroup = false;
+                string? FavouriteRomName = null;
+                if (row["FavouriteRomId"] != DBNull.Value)
+                {
+                    FavouriteRomId = (long?)row["FavouriteRomId"];
+                    FavouriteRomIsMediagroup = (bool)row["FavouriteRomIsMediaGroup"];
+                    FavouriteRomName = (string)row["FavouriteRomName"];
+                }
+
+                AvailablePlatformItem valuePair = new AvailablePlatformItem
+                {
+                    Id = platform.Id,
+                    Name = platform.Name,
+                    Category = platform.Category,
+                    emulatorConfiguration = emulatorConfiguration,
+                    LastPlayedRomId = LastPlayedRomId,
+                    LastPlayedRomIsMediagroup = LastPlayedIsMediagroup,
+                    LastPlayedRomName = LastPlayedRomName,
+                    FavouriteRomId = FavouriteRomId,
+                    FavouriteRomIsMediagroup = FavouriteRomIsMediagroup,
+                    FavouriteRomName = FavouriteRomName
+                };
+                platforms.Add(valuePair);
            }

            return platforms;
        }

+        public static void GameSetFavouriteRom(string UserId, long GameId, long PlatformId, long RomId, bool IsMediaGroup)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM User_GameFavouriteRoms WHERE UserId = @userid AND GameId = @gameid AND PlatformId = @platformid; INSERT INTO User_GameFavouriteRoms (UserId, GameId, PlatformId, RomId, IsMediaGroup) VALUES (@userid, @gameid, @platformid, @romid, @ismediagroup);";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "userid", UserId },
+                { "gameid", GameId },
+                { "platformid", PlatformId },
+                { "romid", RomId },
+                { "ismediagroup", IsMediaGroup }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public static void GameClearFavouriteRom(string UserId, long GameId, long PlatformId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM User_GameFavouriteRoms WHERE UserId = @userid AND GameId = @gameid AND PlatformId = @platformid;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "userid", UserId },
+                { "gameid", GameId },
+                { "platformid", PlatformId }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public class AvailablePlatformItem : IGDB.Models.Platform
+        {
+            public PlatformMapping.UserEmulatorConfiguration emulatorConfiguration { get; set; }
+            public long? LastPlayedRomId { get; set; }
+            public bool? LastPlayedRomIsMediagroup { get; set; }
+            public string? LastPlayedRomName { get; set; }
+            public long? FavouriteRomId { get; set; }
+            public bool? FavouriteRomIsMediagroup { get; set; }
+            public string? FavouriteRomName { get; set; }
+        }
+
        public enum SearchType
        {
            where = 0,
@@ -539,6 +674,7 @@ namespace gaseous_server.Classes.Metadata
                this.Id = gameObject.Id;
                this.Name = gameObject.Name;
                this.Slug = gameObject.Slug;
+                this.Summary = gameObject.Summary;
                this.TotalRating = gameObject.TotalRating;
                this.TotalRatingCount = gameObject.TotalRatingCount;
                this.Cover = gameObject.Cover;
@@ -564,6 +700,7 @@ namespace gaseous_server.Classes.Metadata
            public long Index { get; set; }
            public string Name { get; set; }
            public string Slug { get; set; }
+            public string Summary { get; set; }
            public double? TotalRating { get; set; }
            public int? TotalRatingCount { get; set; }
            public bool HasSavedGame { get; set; } = false;
--- a/gaseous-server/Classes/Metadata/PlatformLogos.cs
+++ b/gaseous-server/Classes/Metadata/PlatformLogos.cs
@@ -76,7 +76,13 @@ namespace gaseous_server.Classes.Metadata
                    {
                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
+                        
+                        // check if old value is different from the new value - only download if it's different
+                        PlatformLogo oldImage = Storage.GetCacheValue<PlatformLogo>(returnValue, "id", (long)searchValue);
+                        if (oldImage.ImageId != returnValue.ImageId)
+                        {
+                            forceImageDownload = true;
+                        }
                    }
                    catch (Exception ex)
                    {
--- a/gaseous-server/Classes/Metadata/PlatformVersions.cs
+++ b/gaseous-server/Classes/Metadata/PlatformVersions.cs
@@ -5,15 +5,15 @@ using IGDB.Models;

 namespace gaseous_server.Classes.Metadata
 {
-	public class PlatformVersions
-	{
+    public class PlatformVersions
+    {
        const string fieldList = "fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;";

        public PlatformVersions()
-		{
-		}
+        {
+        }

-        public static PlatformVersion? GetPlatformVersion(long Id, Platform ParentPlatform)
+        public static PlatformVersion? GetPlatformVersion(long Id, Platform ParentPlatform, bool GetImages = false)
        {
            if (Id == 0)
            {
@@ -21,18 +21,18 @@ namespace gaseous_server.Classes.Metadata
            }
            else
            {
-                Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.id, Id, ParentPlatform);
+                Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.id, Id, ParentPlatform, GetImages);
                return RetVal.Result;
            }
        }

-        public static PlatformVersion GetPlatformVersion(string Slug, Platform ParentPlatform)
+        public static PlatformVersion GetPlatformVersion(string Slug, Platform ParentPlatform, bool GetImages = false)
        {
-            Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.slug, Slug, ParentPlatform);
+            Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.slug, Slug, ParentPlatform, GetImages);
            return RetVal.Result;
        }

-        private static async Task<PlatformVersion> _GetPlatformVersion(SearchUsing searchUsing, object searchValue, Platform ParentPlatform)
+        private static async Task<PlatformVersion> _GetPlatformVersion(SearchUsing searchUsing, object searchValue, Platform ParentPlatform, bool GetImages)
        {
            // check database first
            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
@@ -67,7 +67,7 @@ namespace gaseous_server.Classes.Metadata
                    if (returnValue != null)
                    {
                        Storage.NewCacheValue(returnValue);
-                        UpdateSubClasses(ParentPlatform, returnValue);
+                        UpdateSubClasses(ParentPlatform, returnValue, GetImages);
                    }
                    return returnValue;
                case Storage.CacheStatus.Expired:
@@ -75,7 +75,7 @@ namespace gaseous_server.Classes.Metadata
                    {
                        returnValue = await GetObjectFromServer(WhereClause);
                        Storage.NewCacheValue(returnValue, true);
-                        UpdateSubClasses(ParentPlatform, returnValue);
+                        UpdateSubClasses(ParentPlatform, returnValue, GetImages);
                    }
                    catch (Exception ex)
                    {
@@ -90,17 +90,20 @@ namespace gaseous_server.Classes.Metadata
            }
        }

-        private static void UpdateSubClasses(Platform ParentPlatform, PlatformVersion platformVersion)
+        private static void UpdateSubClasses(Platform ParentPlatform, PlatformVersion platformVersion, bool GetImages)
        {
-            if (platformVersion.PlatformLogo != null)
+            if (GetImages == true)
            {
-                try
+                if (platformVersion.PlatformLogo != null)
                {
-                    PlatformLogo platformLogo = PlatformLogos.GetPlatformLogo(platformVersion.PlatformLogo.Id, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(ParentPlatform), "Versions", platformVersion.Slug));
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Warning, "Platform Update", "Unable to fetch platform logo", ex);
+                    try
+                    {
+                        PlatformLogo platformLogo = PlatformLogos.GetPlatformLogo(platformVersion.PlatformLogo.Id, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(ParentPlatform), "Versions", platformVersion.Slug));
+                    }
+                    catch (Exception ex)
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Platform Update", "Unable to fetch platform logo", ex);
+                    }
                }
            }
        }
--- a/gaseous-server/Classes/Metadata/Platforms.cs
+++ b/gaseous-server/Classes/Metadata/Platforms.cs
@@ -7,16 +7,16 @@ using IGDB.Models;
 namespace gaseous_server.Classes.Metadata
 {
    public class Platforms
-	{
+    {
        const string fieldList = "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;";

        public Platforms()
-		{
+        {

-		}
+        }

-        public static Platform? GetPlatform(long Id, bool forceRefresh = false)
-		{
+        public static Platform? GetPlatform(long Id, bool forceRefresh = false, bool GetImages = false)
+        {
            if (Id == 0)
            {
                Platform returnValue = new Platform();
@@ -41,10 +41,10 @@ namespace gaseous_server.Classes.Metadata
            {
                try
                {
-                    Task<Platform> RetVal = _GetPlatform(SearchUsing.id, Id, forceRefresh);
+                    Task<Platform> RetVal = _GetPlatform(SearchUsing.id, Id, forceRefresh, GetImages);
                    return RetVal.Result;
                }
-                catch(Exception ex)
+                catch (Exception ex)
                {
                    Logging.Log(Logging.LogType.Warning, "Metadata", "An error occurred fetching Platform Id " + Id, ex);
                    return null;
@@ -52,14 +52,14 @@ namespace gaseous_server.Classes.Metadata
            }
        }

-		public static Platform GetPlatform(string Slug, bool forceRefresh = false)
-		{
-			Task<Platform> RetVal = _GetPlatform(SearchUsing.slug, Slug, forceRefresh);
-			return RetVal.Result;
-		}
+        public static Platform GetPlatform(string Slug, bool forceRefresh = false, bool GetImages = false)
+        {
+            Task<Platform> RetVal = _GetPlatform(SearchUsing.slug, Slug, forceRefresh, GetImages);
+            return RetVal.Result;
+        }

-		private static async Task<Platform> _GetPlatform(SearchUsing searchUsing, object searchValue, bool forceRefresh)
-		{
+        private static async Task<Platform> _GetPlatform(SearchUsing searchUsing, object searchValue, bool forceRefresh, bool GetImages)
+        {
            // check database first
            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
            if (searchUsing == SearchUsing.id)
@@ -78,13 +78,16 @@ namespace gaseous_server.Classes.Metadata

            // set up where clause
            string WhereClause = "";
+            string searchField = "";
            switch (searchUsing)
            {
                case SearchUsing.id:
                    WhereClause = "where id = " + searchValue;
+                    searchField = "id";
                    break;
                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
+                    WhereClause = "where slug = \"" + searchValue + "\"";
+                    searchField = "slug";
                    break;
                default:
                    throw new Exception("Invalid search type");
@@ -96,7 +99,7 @@ namespace gaseous_server.Classes.Metadata
                case Storage.CacheStatus.NotPresent:
                    returnValue = await GetObjectFromServer(WhereClause);
                    Storage.NewCacheValue(returnValue);
-                    UpdateSubClasses(returnValue);
+                    UpdateSubClasses(returnValue, GetImages);
                    AddPlatformMapping(returnValue);
                    return returnValue;
                case Storage.CacheStatus.Expired:
@@ -104,23 +107,23 @@ namespace gaseous_server.Classes.Metadata
                    {
                        returnValue = await GetObjectFromServer(WhereClause);
                        Storage.NewCacheValue(returnValue, true);
-                        UpdateSubClasses(returnValue);
+                        UpdateSubClasses(returnValue, GetImages);
                        AddPlatformMapping(returnValue);
                        return returnValue;
                    }
                    catch (Exception ex)
                    {
                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        return Storage.GetCacheValue<Platform>(returnValue, "id", (long)searchValue);
+                        return Storage.GetCacheValue<Platform>(returnValue, searchField, searchValue);
                    }
                case Storage.CacheStatus.Current:
-                    return Storage.GetCacheValue<Platform>(returnValue, "id", (long)searchValue);
+                    return Storage.GetCacheValue<Platform>(returnValue, searchField, searchValue);
                default:
                    throw new Exception("How did you get here?");
            }
        }

-        private static void UpdateSubClasses(Platform platform)
+        private static void UpdateSubClasses(Platform platform, bool GetImages)
        {
            if (platform.Versions != null)
            {
@@ -130,15 +133,18 @@ namespace gaseous_server.Classes.Metadata
                }
            }

-            if (platform.PlatformLogo != null)
+            if (GetImages == true)
            {
-                try
+                if (platform.PlatformLogo != null)
                {
-                    PlatformLogo platformLogo = PlatformLogos.GetPlatformLogo(platform.PlatformLogo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platform));
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Warning, "Platform Update", "Unable to fetch platform logo", ex);
+                    try
+                    {
+                        PlatformLogo platformLogo = PlatformLogos.GetPlatformLogo(platform.PlatformLogo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platform));
+                    }
+                    catch (Exception ex)
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Platform Update", "Unable to fetch platform logo", ex);
+                    }
                }
            }
        }
@@ -158,11 +164,12 @@ namespace gaseous_server.Classes.Metadata
            {
                Logging.Log(Logging.LogType.Information, "Platform Map", "Importing " + platform.Name + " from predefined data.");
                // doesn't exist - add it
-                item = new Models.PlatformMapping.PlatformMapItem{
+                item = new Models.PlatformMapping.PlatformMapItem
+                {
                    IGDBId = (long)platform.Id,
                    IGDBName = platform.Name,
                    IGDBSlug = platform.Slug,
-                    AlternateNames = new List<string>{ platform.AlternativeName }
+                    AlternateNames = new List<string> { platform.AlternativeName }
                };
                Models.PlatformMapping.WritePlatformMap(item, false, true);
            }
--- a/gaseous-server/Classes/Metadata/Screenshots.cs
+++ b/gaseous-server/Classes/Metadata/Screenshots.cs
@@ -5,7 +5,7 @@ using IGDB.Models;

 namespace gaseous_server.Classes.Metadata
 {
-	public class Screenshots
+    public class Screenshots
    {
        const string fieldList = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;";

@@ -74,7 +74,13 @@ namespace gaseous_server.Classes.Metadata
                    {
                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
+
+                        // check if old value is different from the new value - only download if it's different
+                        Screenshot oldImage = Storage.GetCacheValue<Screenshot>(returnValue, "id", (long)searchValue);
+                        if (oldImage.ImageId != returnValue.ImageId)
+                        {
+                            forceImageDownload = true;
+                        }
                    }
                    catch (Exception ex)
                    {
@@ -120,6 +126,6 @@ namespace gaseous_server.Classes.Metadata

            return result;
        }
-	}
+    }
 }

--- a/gaseous-server/Classes/Metadata/Storage.cs
+++ b/gaseous-server/Classes/Metadata/Storage.cs
@@ -7,19 +7,19 @@ using Microsoft.Extensions.Caching.Memory;

 namespace gaseous_server.Classes.Metadata
 {
-	public class Storage
-	{
-		public enum CacheStatus
-		{
-			NotPresent,
-			Current,
-			Expired
-		}
+    public class Storage
+    {
+        public enum CacheStatus
+        {
+            NotPresent,
+            Current,
+            Expired
+        }

-		public static CacheStatus GetCacheStatus(string Endpoint, string Slug)
-		{
+        public static CacheStatus GetCacheStatus(string Endpoint, string Slug)
+        {
            return _GetCacheStatus(Endpoint, "slug", Slug);
-		}
+        }

        public static CacheStatus GetCacheStatus(string Endpoint, long Id)
        {
@@ -47,124 +47,124 @@ namespace gaseous_server.Classes.Metadata
        }

        private static CacheStatus _GetCacheStatus(string Endpoint, string SearchField, object SearchValue)
-		{
+        {
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);

-			string sql = "SELECT lastUpdated FROM " + Endpoint + " WHERE " + SearchField + " = @" + SearchField;
+            string sql = "SELECT lastUpdated FROM " + Endpoint + " WHERE " + SearchField + " = @" + SearchField;

-			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			dbDict.Add("Endpoint", Endpoint);
-			dbDict.Add(SearchField, SearchValue);
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("Endpoint", Endpoint);
+            dbDict.Add(SearchField, SearchValue);

-			DataTable dt = db.ExecuteCMD(sql, dbDict);
-			if (dt.Rows.Count == 0)
-			{
-				// no data stored for this item, or lastUpdated
-				return CacheStatus.NotPresent;
-			}
-			else
-			{
-				DateTime CacheExpiryTime = DateTime.UtcNow.AddHours(-168);
-				if ((DateTime)dt.Rows[0]["lastUpdated"] < CacheExpiryTime)
-				{
-					return CacheStatus.Expired;
-				}
-				else
-				{
-					return CacheStatus.Current;
-				}
-			}
+            DataTable dt = db.ExecuteCMD(sql, dbDict);
+            if (dt.Rows.Count == 0)
+            {
+                // no data stored for this item, or lastUpdated
+                return CacheStatus.NotPresent;
+            }
+            else
+            {
+                DateTime CacheExpiryTime = DateTime.UtcNow.AddHours(-168);
+                if ((DateTime)dt.Rows[0]["lastUpdated"] < CacheExpiryTime)
+                {
+                    return CacheStatus.Expired;
+                }
+                else
+                {
+                    return CacheStatus.Current;
+                }
+            }
        }

-		public static void NewCacheValue(object ObjectToCache, bool UpdateRecord = false)
-		{
-			// get the object type name
-			string ObjectTypeName = ObjectToCache.GetType().Name;
+        public static void NewCacheValue(object ObjectToCache, bool UpdateRecord = false)
+        {
+            // get the object type name
+            string ObjectTypeName = ObjectToCache.GetType().Name;

-			// build dictionary
-			string objectJson = Newtonsoft.Json.JsonConvert.SerializeObject(ObjectToCache);
-			Dictionary<string, object?> objectDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object?>>(objectJson);
+            // build dictionary
+            string objectJson = Newtonsoft.Json.JsonConvert.SerializeObject(ObjectToCache);
+            Dictionary<string, object?> objectDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object?>>(objectJson);
            objectDict.Add("dateAdded", DateTime.UtcNow);
            objectDict.Add("lastUpdated", DateTime.UtcNow);

-			// generate sql
-			string fieldList = "";
-			string valueList = "";
-			string updateFieldValueList = "";
-			foreach (KeyValuePair<string, object?> key in objectDict)
-			{
-				if (fieldList.Length > 0)
-				{
-					fieldList = fieldList + ", ";
-					valueList = valueList + ", ";
-				}
-				fieldList = fieldList + key.Key;
-				valueList = valueList + "@" + key.Key;
-				if ((key.Key != "id") && (key.Key != "dateAdded"))
+            // generate sql
+            string fieldList = "";
+            string valueList = "";
+            string updateFieldValueList = "";
+            foreach (KeyValuePair<string, object?> key in objectDict)
+            {
+                if (fieldList.Length > 0)
+                {
+                    fieldList = fieldList + ", ";
+                    valueList = valueList + ", ";
+                }
+                fieldList = fieldList + key.Key;
+                valueList = valueList + "@" + key.Key;
+                if ((key.Key != "id") && (key.Key != "dateAdded"))
                {
                    if (updateFieldValueList.Length > 0)
                    {
                        updateFieldValueList = updateFieldValueList + ", ";
                    }
                    updateFieldValueList += key.Key + " = @" + key.Key;
-				}
+                }

-				// check property type
-				Type objectType = ObjectToCache.GetType();
-				if (objectType != null)
-				{
-					PropertyInfo objectProperty = objectType.GetProperty(key.Key);
-					if (objectProperty != null)
-					{
-						string compareName = objectProperty.PropertyType.Name.ToLower().Split("`")[0];
-						var objectValue = objectProperty.GetValue(ObjectToCache);
-						if (objectValue != null)
-						{
-							string newObjectValue;
-							Dictionary<string, object> newDict;
+                // check property type
+                Type objectType = ObjectToCache.GetType();
+                if (objectType != null)
+                {
+                    PropertyInfo objectProperty = objectType.GetProperty(key.Key);
+                    if (objectProperty != null)
+                    {
+                        string compareName = objectProperty.PropertyType.Name.ToLower().Split("`")[0];
+                        var objectValue = objectProperty.GetValue(ObjectToCache);
+                        if (objectValue != null)
+                        {
+                            string newObjectValue;
+                            Dictionary<string, object> newDict;
                            switch (compareName)
-							{
-								case "identityorvalue":
+                            {
+                                case "identityorvalue":
                                    newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(objectValue);
-									newDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(newObjectValue);
+                                    newDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(newObjectValue);
                                    objectDict[key.Key] = newDict["Id"];
                                    break;
                                case "identitiesorvalues":
                                    newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(objectValue);
                                    newDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(newObjectValue);
-									newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(newDict["Ids"]);
+                                    newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(newDict["Ids"]);
                                    objectDict[key.Key] = newObjectValue;

                                    StoreRelations(ObjectTypeName, key.Key, (long)objectDict["Id"], newObjectValue);

                                    break;
-								case "int32[]":
+                                case "int32[]":
                                    newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(objectValue);
                                    objectDict[key.Key] = newObjectValue;
                                    break;
                            }
-						}
-					}
-				}
-			}
-
-			string sql = "";
-			if (UpdateRecord == false)
-			{
-				sql = "INSERT INTO " + ObjectTypeName + " (" + fieldList + ") VALUES (" + valueList + ")";
+                        }
+                    }
+                }
+            }
+
+            string sql = "";
+            if (UpdateRecord == false)
+            {
+                sql = "INSERT INTO " + ObjectTypeName + " (" + fieldList + ") VALUES (" + valueList + ")";
+            }
+            else
+            {
+                sql = "UPDATE " + ObjectTypeName + " SET " + updateFieldValueList + " WHERE Id = @Id";
            }
-			else
-			{
-				sql = "UPDATE " + ObjectTypeName + " SET " + updateFieldValueList + " WHERE Id = @Id";
-			}

            // execute sql
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			db.ExecuteCMD(sql, objectDict);
+            db.ExecuteCMD(sql, objectDict);
        }

-		public static T GetCacheValue<T>(T EndpointType, string SearchField, object SearchValue)
-		{
+        public static T GetCacheValue<T>(T EndpointType, string SearchField, object SearchValue)
+        {
            string Endpoint = EndpointType.GetType().Name;

            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
@@ -175,23 +175,23 @@ namespace gaseous_server.Classes.Metadata
            dbDict.Add("Endpoint", Endpoint);
            dbDict.Add(SearchField, SearchValue);

-            DataTable dt = db.ExecuteCMD(sql, dbDict);
+            DataTable dt = db.ExecuteCMD(sql, dbDict, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromHours(8).Ticks));
            if (dt.Rows.Count == 0)
            {
-				// no data stored for this item
-				throw new Exception("No record found that matches endpoint " + Endpoint + " with search value " + SearchValue);
+                // no data stored for this item
+                throw new Exception("No record found that matches endpoint " + Endpoint + " with search value " + SearchValue);
            }
            else
            {
-				DataRow dataRow = dt.Rows[0];
+                DataRow dataRow = dt.Rows[0];
                object returnObject = BuildCacheObject<T>(EndpointType, dataRow);

                return (T)returnObject;
            }
        }

-		public static T BuildCacheObject<T>(T EndpointType, DataRow dataRow)
-		{
+        public static T BuildCacheObject<T>(T EndpointType, DataRow dataRow)
+        {
            foreach (PropertyInfo property in EndpointType.GetType().GetProperties())
            {
                if (dataRow.Table.Columns.Contains(property.Name))
@@ -428,6 +428,30 @@ namespace gaseous_server.Classes.Metadata
            }
        }

+        public static void CreateRelationsTables<T>()
+        {
+            string PrimaryTable = typeof(T).Name;
+            foreach (PropertyInfo property in typeof(T).GetProperties())
+            {
+                string SecondaryTable = property.Name;
+
+                if (property.PropertyType.Name == "IdentitiesOrValues`1")
+                {
+
+                    string TableName = "Relation_" + PrimaryTable + "_" + SecondaryTable;
+                    Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                    string sql = "SELECT * FROM information_schema.tables WHERE table_schema = '" + Config.DatabaseConfiguration.DatabaseName + "' AND table_name = '" + TableName + "';";
+                    DataTable data = db.ExecuteCMD(sql);
+                    if (data.Rows.Count == 0)
+                    {
+                        // table doesn't exist, create it
+                        sql = "CREATE TABLE `" + Config.DatabaseConfiguration.DatabaseName + "`.`" + TableName + "` (`" + PrimaryTable + "Id` BIGINT NOT NULL, `" + SecondaryTable + "Id` BIGINT NOT NULL, PRIMARY KEY (`" + PrimaryTable + "Id`, `" + SecondaryTable + "Id`), INDEX `idx_PrimaryColumn` (`" + PrimaryTable + "Id` ASC) VISIBLE);";
+                        db.ExecuteCMD(sql);
+                    }
+                }
+            }
+        }
+
        private class MemoryCacheObject
        {
            public object Object { get; set; }
--- a/gaseous-server/Classes/RomMediaGroup.cs
+++ b/gaseous-server/Classes/RomMediaGroup.cs
@@ -11,12 +11,12 @@ using gaseous_server.Models;

 namespace gaseous_server.Classes
 {
-	public class RomMediaGroup
+    public class RomMediaGroup
    {
        public class InvalidMediaGroupId : Exception
        {
            public InvalidMediaGroupId(long Id) : base("Unable to find media group by id " + Id)
-            {}
+            { }
        }

        public static GameRomMediaGroupItem CreateMediaGroup(long GameId, long PlatformId, List<long> RomIds)
@@ -81,14 +81,42 @@ namespace gaseous_server.Classes
            }
        }

-        public static List<GameRomMediaGroupItem> GetMediaGroupsFromGameId(long GameId, string userid = "")
+        public static List<GameRomMediaGroupItem> GetMediaGroupsFromGameId(long GameId, string userid = "", long? PlatformId = null)
        {
+            string PlatformWhereClause = "";
+            if (PlatformId != null)
+            {
+                PlatformWhereClause = " AND RomMediaGroup.PlatformId=@platformid";
+            }
+
+            string UserFields = "";
+            string UserJoin = "";
+            if (userid.Length > 0)
+            {
+                UserFields = ", User_RecentPlayedRoms.RomId AS MostRecentRomId, User_RecentPlayedRoms.IsMediaGroup AS MostRecentRomIsMediaGroup, User_GameFavouriteRoms.RomId AS FavouriteRomId, User_GameFavouriteRoms.IsMediaGroup AS FavouriteRomIsMediaGroup";
+                UserJoin = @"
+					LEFT JOIN
+				User_RecentPlayedRoms ON User_RecentPlayedRoms.UserId = @userid
+					AND User_RecentPlayedRoms.GameId = RomMediaGroup.GameId
+					AND User_RecentPlayedRoms.PlatformId = RomMediaGroup.PlatformId
+                    AND User_RecentPlayedRoms.RomId = RomMediaGroup.Id
+					AND User_RecentPlayedRoms.IsMediaGroup = 1
+					LEFT JOIN
+				User_GameFavouriteRoms ON User_GameFavouriteRoms.UserId = @userid
+					AND User_GameFavouriteRoms.GameId = RomMediaGroup.GameId
+					AND User_GameFavouriteRoms.PlatformId = RomMediaGroup.PlatformId
+                    AND User_GameFavouriteRoms.RomId = RomMediaGroup.Id
+					AND User_GameFavouriteRoms.IsMediaGroup = 1
+				";
+            }
+
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT DISTINCT RomMediaGroup.*, GameState.RomId AS GameStateRomId FROM gaseous.RomMediaGroup LEFT JOIN GameState ON RomMediaGroup.Id = GameState.RomId AND GameState.IsMediaGroup = 1 AND GameState.UserId = @userid WHERE RomMediaGroup.GameId=@gameid;";
+            string sql = "SELECT DISTINCT RomMediaGroup.*, GameState.RomId AS GameStateRomId" + UserFields + " FROM gaseous.RomMediaGroup LEFT JOIN GameState ON RomMediaGroup.Id = GameState.RomId AND GameState.IsMediaGroup = 1 AND GameState.UserId = @userid " + UserJoin + " WHERE RomMediaGroup.GameId=@gameid" + PlatformWhereClause + ";";
            Dictionary<string, object> dbDict = new Dictionary<string, object>
            {
                { "gameid", GameId },
-                { "userid", userid }
+                { "userid", userid },
+                { "platformid", PlatformId }
            };

            DataTable dataTable = db.ExecuteCMD(sql, dbDict);
@@ -165,7 +193,7 @@ namespace gaseous_server.Classes
        public static void DeleteMediaGroup(long Id)
        {
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "DELETE FROM RomMediaGroup WHERE Id=@id; DELETE FROM GameState WHERE RomId=@id AND IsMediaGroup=1;";
+            string sql = "DELETE FROM RomMediaGroup WHERE Id=@id; DELETE FROM GameState WHERE RomId=@id AND IsMediaGroup=1; UPDATE UserTimeTracking SET PlatformId = NULL, IsMediaGroup = NULL, RomId = NULL WHERE RomId=@id AND IsMediaGroup = 1;";
            Dictionary<string, object> dbDict = new Dictionary<string, object>();
            dbDict.Add("id", Id);
            db.ExecuteCMD(sql, dbDict);
@@ -180,22 +208,42 @@ namespace gaseous_server.Classes
        internal static GameRomMediaGroupItem BuildMediaGroupFromRow(DataRow row)
        {
            bool hasSaveStates = false;
-			if (row.Table.Columns.Contains("GameStateRomId"))
-			{
-				if (row["GameStateRomId"] != DBNull.Value)
-				{
-					hasSaveStates = true;
-				}
-			}
+            if (row.Table.Columns.Contains("GameStateRomId"))
+            {
+                if (row["GameStateRomId"] != DBNull.Value)
+                {
+                    hasSaveStates = true;
+                }
+            }

-            GameRomMediaGroupItem mediaGroupItem = new GameRomMediaGroupItem();
-            mediaGroupItem.Id = (long)row["Id"];
-            mediaGroupItem.Status = (GameRomMediaGroupItem.GroupBuildStatus)row["Status"];
-            mediaGroupItem.PlatformId = (long)row["PlatformId"];
-            mediaGroupItem.GameId = (long)row["GameId"];
-            mediaGroupItem.RomIds = new List<long>();
-            mediaGroupItem.Roms = new List<Roms.GameRomItem>();
-            mediaGroupItem.HasSaveStates = hasSaveStates;
+            GameRomMediaGroupItem mediaGroupItem = new GameRomMediaGroupItem
+            {
+                Id = (long)row["Id"],
+                Status = (GameRomMediaGroupItem.GroupBuildStatus)row["Status"],
+                PlatformId = (long)row["PlatformId"],
+                GameId = (long)row["GameId"],
+                RomIds = new List<long>(),
+                Roms = new List<Roms.GameRomItem>(),
+                HasSaveStates = hasSaveStates
+            };
+
+            mediaGroupItem.RomUserLastUsed = false;
+            if (row.Table.Columns.Contains("MostRecentRomId"))
+            {
+                if (row["MostRecentRomId"] != DBNull.Value)
+                {
+                    mediaGroupItem.RomUserLastUsed = true;
+                }
+            }
+
+            mediaGroupItem.RomUserFavourite = false;
+            if (row.Table.Columns.Contains("FavouriteRomId"))
+            {
+                if (row["FavouriteRomId"] != DBNull.Value)
+                {
+                    mediaGroupItem.RomUserFavourite = true;
+                }
+            }

            // get members
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
@@ -216,18 +264,6 @@ namespace gaseous_server.Classes
                }
            }

-            // check for a web emulator and update the romItem
-			foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
-			{
-				if (platformMapping.IGDBId == mediaGroupItem.PlatformId)
-				{
-					if (platformMapping.WebEmulator != null)
-					{
-						mediaGroupItem.Emulator = platformMapping.WebEmulator;
-					}
-				}
-			}
-
            return mediaGroupItem;
        }

@@ -301,7 +337,7 @@ namespace gaseous_server.Classes
                        if (File.Exists(rom.Path))
                        {
                            string romExt = Path.GetExtension(rom.Path);
-                            if (new string[]{ ".zip", ".rar", ".7z" }.Contains(romExt))
+                            if (new string[] { ".zip", ".rar", ".7z" }.Contains(romExt))
                            {
                                Logging.Log(Logging.LogType.Information, "Media Group", "Decompressing ROM: " + rom.Name);

@@ -511,11 +547,12 @@ namespace gaseous_server.Classes
        }

        public class GameRomMediaGroupItem
-		{
-			public long Id { get; set; }
-			public long GameId { get; set; }
-			public long PlatformId { get; set; }
-            public string Platform {
+        {
+            public long Id { get; set; }
+            public long GameId { get; set; }
+            public long PlatformId { get; set; }
+            public string Platform
+            {
                get
                {
                    try
@@ -528,37 +565,40 @@ namespace gaseous_server.Classes
                    }
                }
            }
-            public Models.PlatformMapping.PlatformMapItem.WebEmulatorItem? Emulator { get; set; }
-			public List<long> RomIds { get; set; }
+            public List<long> RomIds { get; set; }
            public List<Roms.GameRomItem> Roms { get; set; }
            public bool HasSaveStates { get; set; } = false;
-			private GroupBuildStatus _Status { get; set; }
-			public GroupBuildStatus Status {
-				get
-				{
-					if (_Status == GroupBuildStatus.Completed)
-					{
-						if (File.Exists(MediaGroupZipPath))
-						{
-							return GroupBuildStatus.Completed;
-						}
-						else
-						{
-							return GroupBuildStatus.NoStatus;
-						}
-					}
-					else
-					{
-						return _Status;
-					}
-				}
+            public bool RomUserLastUsed { get; set; }
+            public bool RomUserFavourite { get; set; }
+            private GroupBuildStatus _Status { get; set; }
+            public GroupBuildStatus Status
+            {
+                get
+                {
+                    if (_Status == GroupBuildStatus.Completed)
+                    {
+                        if (File.Exists(MediaGroupZipPath))
+                        {
+                            return GroupBuildStatus.Completed;
+                        }
+                        else
+                        {
+                            return GroupBuildStatus.NoStatus;
+                        }
+                    }
+                    else
+                    {
+                        return _Status;
+                    }
+                }
                set
                {
                    _Status = value;
                }
-			}
-			public long? Size {
-				get
+            }
+            public long? Size
+            {
+                get
                {
                    if (Status == GroupBuildStatus.Completed)
                    {
@@ -577,15 +617,15 @@ namespace gaseous_server.Classes
                        return 0;
                    }
                }
-			}
-			internal string MediaGroupZipPath
-			{
-				get
-				{
-					return Path.Combine(Config.LibraryConfiguration.LibraryMediaGroupDirectory, Id + ".zip");
-				}
-			}
-			public enum GroupBuildStatus
+            }
+            internal string MediaGroupZipPath
+            {
+                get
+                {
+                    return Path.Combine(Config.LibraryConfiguration.LibraryMediaGroupDirectory, Id + ".zip");
+                }
+            }
+            public enum GroupBuildStatus
            {
                NoStatus = 0,
                WaitingForBuild = 1,
@@ -593,6 +633,6 @@ namespace gaseous_server.Classes
                Completed = 3,
                Failed = 4
            }
-		}
+        }
    }
 }
--- a/gaseous-server/Classes/Roms.cs
+++ b/gaseous-server/Classes/Roms.cs
@@ -4,27 +4,36 @@ using gaseous_signature_parser.models.RomSignatureObject;
 using static gaseous_server.Classes.RomMediaGroup;
 using gaseous_server.Classes.Metadata;
 using IGDB.Models;
+using static HasheousClient.Models.FixMatchModel;
+using NuGet.Protocol.Core.Types;
+using static gaseous_server.Classes.FileSignature;

 namespace gaseous_server.Classes
 {
 	public class Roms
 	{
 		public class InvalidRomId : Exception
-        { 
-            public InvalidRomId(long Id) : base("Unable to find ROM by id " + Id)
-            {}
-        }
+		{
+			public InvalidRomId(long Id) : base("Unable to find ROM by id " + Id)
+			{ }
+		}
+
+		public class InvalidRomHash : Exception
+		{
+			public InvalidRomHash(String Hash) : base("Unable to find ROM by hash " + Hash)
+			{ }
+		}

 		public static GameRomObject GetRoms(long GameId, long PlatformId = -1, string NameSearch = "", int pageNumber = 0, int pageSize = 0, string userid = "")
 		{
 			GameRomObject GameRoms = new GameRomObject();

-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "";
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
 			string sqlCount = "";
 			string sqlPlatform = "";
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("id", GameId);
+			dbDict.Add("id", GameId);
 			dbDict.Add("userid", userid);

 			string NameSearchWhere = "";
@@ -34,56 +43,78 @@ namespace gaseous_server.Classes
 				dbDict.Add("namesearch", '%' + NameSearch + '%');
 			}

+			string UserFields = "";
+			string UserJoin = "";
+			if (userid.Length > 0)
+			{
+				UserFields = ", User_RecentPlayedRoms.RomId AS MostRecentRomId, User_RecentPlayedRoms.IsMediaGroup AS MostRecentRomIsMediaGroup, User_GameFavouriteRoms.RomId AS FavouriteRomId, User_GameFavouriteRoms.IsMediaGroup AS FavouriteRomIsMediaGroup";
+				UserJoin = @"
+					LEFT JOIN
+				User_RecentPlayedRoms ON User_RecentPlayedRoms.UserId = @userid
+					AND User_RecentPlayedRoms.GameId = Games_Roms.GameId
+					AND User_RecentPlayedRoms.PlatformId = Games_Roms.PlatformId
+					AND User_RecentPlayedRoms.RomId = Games_Roms.Id
+					AND User_RecentPlayedRoms.IsMediaGroup = 0
+					LEFT JOIN
+				User_GameFavouriteRoms ON User_GameFavouriteRoms.UserId = @userid
+					AND User_GameFavouriteRoms.GameId = Games_Roms.GameId
+					AND User_GameFavouriteRoms.PlatformId = Games_Roms.PlatformId
+					AND User_GameFavouriteRoms.RomId = Games_Roms.Id
+					AND User_GameFavouriteRoms.IsMediaGroup = 0
+				";
+			}
+
 			// platform query
 			sqlPlatform = "SELECT DISTINCT Games_Roms.PlatformId, Platform.`Name` FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id WHERE GameId = @id ORDER BY Platform.`Name`;";

-			if (PlatformId == -1) {
+			if (PlatformId == -1)
+			{
 				// data query
-				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, GameState.RomId AS SavedStateRomId FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) WHERE Games_Roms.GameId = @id" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";
+				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename, GameState.RomId AS SavedStateRomId" + UserFields + " FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON Games_Roms.GameId = Game.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) " + UserJoin + " WHERE Games_Roms.GameId = @id" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";

 				// count query
 				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.GameId = @id" + NameSearchWhere + ";";
-			} else {
+			}
+			else
+			{
 				// data query
-				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, GameState.RomId AS SavedStateRomId FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";
+				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename, GameState.RomId AS SavedStateRomId" + UserFields + " FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON Games_Roms.GameId = Game.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) " + UserJoin + " WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";

 				// count query
 				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + ";";

 				dbDict.Add("platformid", PlatformId);
 			}
-            DataTable romDT = db.ExecuteCMD(sql, dbDict);
-			Dictionary<string, object> rowCount = db.ExecuteCMDDict(sqlCount, dbDict)[0];
-			DataTable platformDT = db.ExecuteCMD(sqlPlatform, dbDict);
+			DataTable romDT = db.ExecuteCMD(sql, dbDict, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromMinutes(1).Ticks));
+			Dictionary<string, object> rowCount = db.ExecuteCMDDict(sqlCount, dbDict, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromMinutes(1).Ticks))[0];

-            if (romDT.Rows.Count > 0)
-            {
+			if (romDT.Rows.Count > 0)
+			{
 				// set count of roms
 				GameRoms.Count = int.Parse((string)rowCount["RomCount"]);

 				int pageOffset = pageSize * (pageNumber - 1);
 				for (int i = 0; i < romDT.Rows.Count; i++)
 				{
-					GameRomItem gameRomItem = BuildRom(romDT.Rows[i]);
-
 					if ((i >= pageOffset && i < pageOffset + pageSize) || pageSize == 0)
 					{
+						GameRomItem gameRomItem = BuildRom(romDT.Rows[i]);
 						GameRoms.GameRomItems.Add(gameRomItem);
 					}
 				}

 				return GameRoms;
-            }
-            else
-            {
-                throw new Games.InvalidGameId(GameId);
-            }
-        }
+			}
+			else
+			{
+				throw new Games.InvalidGameId(GameId);
+			}
+		}

 		public static GameRomItem GetRom(long RomId)
 		{
 			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql = "SELECT Games_Roms.*, Platform.`Name` AS platformname FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id WHERE Games_Roms.Id = @id";
+			string sql = "SELECT Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON Games_Roms.GameId = Game.Id WHERE Games_Roms.Id = @id";
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
 			dbDict.Add("id", RomId);
 			DataTable romDT = db.ExecuteCMD(sql, dbDict);
@@ -100,6 +131,26 @@ namespace gaseous_server.Classes
 			}
 		}

+		public static GameRomItem GetRom(string MD5)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON Games_Roms.GameId = Game.Id WHERE Games_Roms.MD5 = @id";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			dbDict.Add("id", MD5);
+			DataTable romDT = db.ExecuteCMD(sql, dbDict);
+
+			if (romDT.Rows.Count > 0)
+			{
+				DataRow romDR = romDT.Rows[0];
+				GameRomItem romItem = BuildRom(romDR);
+				return romItem;
+			}
+			else
+			{
+				throw new InvalidRomHash(MD5);
+			}
+		}
+
 		public static GameRomItem UpdateRom(long RomId, long PlatformId, long GameId)
 		{
 			// ensure metadata for platformid is present
@@ -108,18 +159,65 @@ namespace gaseous_server.Classes
 			// ensure metadata for gameid is present
 			IGDB.Models.Game game = Classes.Metadata.Games.GetGame(GameId, false, false, false);

-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid WHERE Id = @id";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("id", RomId);
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid WHERE Id = @id";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			dbDict.Add("id", RomId);
 			dbDict.Add("platformid", PlatformId);
 			dbDict.Add("gameid", GameId);
 			db.ExecuteCMD(sql, dbDict);

 			GameRomItem rom = GetRom(RomId);

+			// send update to Hasheous if enabled
+			if (PlatformId != 0 && GameId != 0)
+			{
+				if (Config.MetadataConfiguration.HasheousSubmitFixes == true)
+				{
+					if (
+						Config.MetadataConfiguration.SignatureSource == HasheousClient.Models.MetadataModel.SignatureSources.Hasheous &&
+						(
+							Config.MetadataConfiguration.HasheousAPIKey != null &&
+							Config.MetadataConfiguration.HasheousAPIKey != "")
+						)
+					{
+						try
+						{
+							// find signature used for identifing the rom
+							string md5String = rom.Md5;
+							string sha1String = rom.Sha1;
+							if (rom.Attributes.ContainsKey("ZipContents"))
+							{
+								bool selectorFound = false;
+								List<ArchiveData> archiveDataValues = Newtonsoft.Json.JsonConvert.DeserializeObject<List<ArchiveData>>(rom.Attributes["ZipContents"].ToString());
+								foreach (ArchiveData archiveData in archiveDataValues)
+								{
+									if (archiveData.isSignatureSelector == true)
+									{
+										md5String = archiveData.MD5;
+										sha1String = archiveData.SHA1;
+										selectorFound = true;
+										break;
+									}
+								}
+							}
+
+							HasheousClient.WebApp.HttpHelper.AddHeader("X-API-Key", Config.MetadataConfiguration.HasheousAPIKey);
+							HasheousClient.Hasheous hasheousClient = new HasheousClient.Hasheous();
+							List<MetadataMatch> metadataMatchList = new List<MetadataMatch>();
+							metadataMatchList.Add(new MetadataMatch(HasheousClient.Models.MetadataSources.IGDB, platform.Slug, game.Slug));
+							hasheousClient.FixMatch(new HasheousClient.Models.FixMatchModel(md5String, sha1String, metadataMatchList));
+						}
+						catch (Exception ex)
+						{
+							Logging.Log(Logging.LogType.Critical, "Fix Match", "An error occurred while sending a fixed match to Hasheous.", ex);
+						}
+					}
+				}
+			}
+
 			return rom;
-        }
+		}

 		public static void DeleteRom(long RomId)
 		{
@@ -132,12 +230,12 @@ namespace gaseous_server.Classes
 				}

 				Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-				string sql = "DELETE FROM Games_Roms WHERE Id = @id; DELETE FROM GameState WHERE RomId = @id;";
+				string sql = "DELETE FROM Games_Roms WHERE Id = @id; DELETE FROM GameState WHERE RomId = @id; UPDATE UserTimeTracking SET PlatformId = NULL, IsMediaGroup = NULL, RomId = NULL WHERE RomId = @id AND IsMediaGroup = 0;";
 				Dictionary<string, object> dbDict = new Dictionary<string, object>();
 				dbDict.Add("id", RomId);
 				db.ExecuteCMD(sql, dbDict);
 			}
-        }
+		}

 		private static GameRomItem BuildRom(DataRow romDR)
 		{
@@ -150,43 +248,66 @@ namespace gaseous_server.Classes
 				}
 			}

+			Dictionary<string, object> romAttributes = new Dictionary<string, object>();
+			if (romDR["attributes"] != DBNull.Value)
+			{
+				try
+				{
+					if ((string)romDR["attributes"] != "[ ]")
+					{
+						romAttributes = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>((string)romDR["attributes"]);
+					}
+				}
+				catch (Exception ex)
+				{
+					Logging.Log(Logging.LogType.Warning, "Roms", "Error parsing rom attributes: " + ex.Message);
+				}
+			}
+
 			GameRomItem romItem = new GameRomItem
-            {
-                Id = (long)romDR["id"],
-                PlatformId = (long)romDR["platformid"],
+			{
+				Id = (long)romDR["id"],
+				PlatformId = (long)romDR["platformid"],
 				Platform = (string)romDR["platformname"],
-                GameId = (long)romDR["gameid"],
-                Name = (string)romDR["name"],
-                Size = (long)romDR["size"],
-                Crc = ((string)romDR["crc"]).ToLower(),
-                Md5 = ((string)romDR["md5"]).ToLower(),
-                Sha1 = ((string)romDR["sha1"]).ToLower(),
-                DevelopmentStatus = (string)romDR["developmentstatus"],
-                Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<List<KeyValuePair<string, object>>>((string)Common.ReturnValueIfNull(romDR["attributes"], "[ ]")),
-                RomType = (HasheousClient.Models.LookupResponseModel.RomItem.RomTypes)(int)romDR["romtype"],
-                RomTypeMedia = (string)romDR["romtypemedia"],
-                MediaLabel = (string)romDR["medialabel"],
-                Path = (string)romDR["path"],
+				GameId = (long)romDR["gameid"],
+				Game = (string)romDR["gamename"],
+				Name = (string)romDR["name"],
+				Size = (long)romDR["size"],
+				Crc = ((string)romDR["crc"]).ToLower(),
+				Md5 = ((string)romDR["md5"]).ToLower(),
+				Sha1 = ((string)romDR["sha1"]).ToLower(),
+				DevelopmentStatus = (string)romDR["developmentstatus"],
+				Attributes = romAttributes,
+				RomType = (HasheousClient.Models.SignatureModel.RomItem.RomTypes)(int)romDR["romtype"],
+				RomTypeMedia = (string)romDR["romtypemedia"],
+				MediaLabel = (string)romDR["medialabel"],
+				Path = (string)romDR["path"],
 				SignatureSource = (gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType)(Int32)romDR["metadatasource"],
 				SignatureSourceGameTitle = (string)Common.ReturnValueIfNull(romDR["MetadataGameName"], ""),
 				HasSaveStates = hasSaveStates,
 				Library = GameLibrary.GetLibrary((int)romDR["LibraryId"])
-            };
+			};

-			// check for a web emulator and update the romItem
-			foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
+			romItem.RomUserLastUsed = false;
+			if (romDR.Table.Columns.Contains("MostRecentRomId"))
 			{
-				if (platformMapping.IGDBId == romItem.PlatformId)
+				if (romDR["MostRecentRomId"] != DBNull.Value)
 				{
-					if (platformMapping.WebEmulator != null)
-					{
-						romItem.Emulator = platformMapping.WebEmulator;
-					}
+					romItem.RomUserLastUsed = true;
 				}
 			}

-            return romItem;
-        }
+			romItem.RomUserFavourite = false;
+			if (romDR.Table.Columns.Contains("FavouriteRomId"))
+			{
+				if (romDR["FavouriteRomId"] != DBNull.Value)
+				{
+					romItem.RomUserFavourite = true;
+				}
+			}
+
+			return romItem;
+		}

 		public class GameRomObject
 		{
@@ -194,17 +315,19 @@ namespace gaseous_server.Classes
 			public int Count { get; set; }
 		}

-		public class GameRomItem : HasheousClient.Models.LookupResponseModel.RomItem
+		public class GameRomItem : HasheousClient.Models.SignatureModel.RomItem
 		{
 			public long PlatformId { get; set; }
 			public string Platform { get; set; }
-            public Models.PlatformMapping.PlatformMapItem.WebEmulatorItem? Emulator { get; set; }
-            public long GameId { get; set; }
+			public long GameId { get; set; }
+			public string Game { get; set; }
 			public string? Path { get; set; }
-			public string? SignatureSourceGameTitle { get; set;}
+			public string? SignatureSourceGameTitle { get; set; }
 			public bool HasSaveStates { get; set; } = false;
 			public GameLibrary.LibraryItem Library { get; set; }
-        }
-    }
+			public bool RomUserLastUsed { get; set; }
+			public bool RomUserFavourite { get; set; }
+		}
+	}
 }

--- a/gaseous-server/Classes/SignatureIngestors/XML.cs
+++ b/gaseous-server/Classes/SignatureIngestors/XML.cs
@@ -8,21 +8,49 @@ namespace gaseous_server.SignatureIngestors.XML
 {
    public class XMLIngestor : QueueItemStatus
    {
-        public void Import(string SearchPath, gaseous_signature_parser.parser.SignatureParser XMLType)
+        public void Import(string SearchPath, string ProcessedDirectory, gaseous_signature_parser.parser.SignatureParser XMLType)
        {
            // connect to database
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);

+            string? XMLDBSearchPath = null;
+            string? XMLDBProcessedDirectory = null;
+            if (XMLType == gaseous_signature_parser.parser.SignatureParser.NoIntro)
+            {
+                XMLDBSearchPath = Path.Combine(SearchPath, "DB");
+                XMLDBProcessedDirectory = Path.Combine(ProcessedDirectory, "DB");
+                SearchPath = Path.Combine(SearchPath, "DAT");
+                ProcessedDirectory = Path.Combine(ProcessedDirectory, "DAT");
+            }
+
            // process provided files
-            Logging.Log(Logging.LogType.Information, "Signature Ingestor - XML", "Importing from " + SearchPath);
            if (!Directory.Exists(SearchPath))
            {
                Directory.CreateDirectory(SearchPath);
            }
+            if (!Directory.Exists(ProcessedDirectory))
+            {
+                Directory.CreateDirectory(ProcessedDirectory);
+            }

            string[] PathContents = Directory.GetFiles(SearchPath);
            Array.Sort(PathContents);

+            string[]? DBPathContents = null;
+            if (XMLDBSearchPath != null)
+            {
+                if (!Directory.Exists(XMLDBSearchPath))
+                {
+                    Directory.CreateDirectory(XMLDBSearchPath);
+                }
+                if (!Directory.Exists(XMLDBProcessedDirectory))
+                {
+                    Directory.CreateDirectory(XMLDBProcessedDirectory);
+                }
+
+                DBPathContents = Directory.GetFiles(XMLDBSearchPath);
+            }
+
            string sql = "";
            Dictionary<string, object> dbDict = new Dictionary<string, object>();
            System.Data.DataTable sigDB;
@@ -33,226 +61,380 @@ namespace gaseous_server.SignatureIngestors.XML

                SetStatus(i + 1, PathContents.Length, "Processing signature file: " + XMLFile);

-                if (Common.SkippableFiles.Contains(Path.GetFileName(XMLFile), StringComparer.OrdinalIgnoreCase))
-                {
-                    Logging.Log(Logging.LogType.Information, "Signature Ingestor - XML", "Skipping file: " + XMLFile);
-                }
-                else
-                {
-                    // check xml file md5
-                    Common.hashObject hashObject = new Common.hashObject(XMLFile);
-                    sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
-                    dbDict = new Dictionary<string, object>();
-                    dbDict.Add("sourcemd5", hashObject.md5hash);
-                    sigDB = db.ExecuteCMD(sql, dbDict);
+                Logging.Log(Logging.LogType.Information, "Signature Ingest", "(" + (i + 1) + " / " + PathContents.Length + ") Processing " + XMLType.ToString() + " DAT file: " + XMLFile);

-                    if (sigDB.Rows.Count == 0)
+                string? DBFile = null;
+                if (XMLDBSearchPath != null)
+                {
+                    switch (XMLType)
                    {
-                        try
-                        {
-                            Logging.Log(Logging.LogType.Information, "Signature Ingestor - XML", "Importing file: " + XMLFile);
-
-                            // start parsing file
-                            gaseous_signature_parser.parser Parser = new gaseous_signature_parser.parser();
-                            RomSignatureObject Object = Parser.ParseSignatureDAT(XMLFile, XMLType);
-
-                            // store in database
-                            string[] flipNameAndDescription = {
-                                "MAMEArcade",
-                                "MAMEMess"
-                            };
-
-                            // store source object
-                            bool processGames = false;
-                            if (Object.SourceMd5 != null)
+                        case gaseous_signature_parser.parser.SignatureParser.NoIntro:
+                            for (UInt16 x = 0; x < DBPathContents.Length; x++)
                            {
-                                sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
-                                dbDict = new Dictionary<string, object>();
-                                string sourceUriStr = "";
-                                if (Object.Url != null)
+                                string tempDBFileName = Path.GetFileNameWithoutExtension(DBPathContents[x].Replace(" (DB Export)", ""));
+                                if (tempDBFileName == Path.GetFileNameWithoutExtension(XMLFile))
                                {
-                                    sourceUriStr = Object.Url.ToString();
+                                    DBFile = DBPathContents[x];
+                                    Logging.Log(Logging.LogType.Information, "Signature Ingest", "Using DB file: " + DBFile);
+                                    break;
                                }
-                                dbDict.Add("name", Common.ReturnValueIfNull(Object.Name, ""));
-                                dbDict.Add("description", Common.ReturnValueIfNull(Object.Description, ""));
-                                dbDict.Add("category", Common.ReturnValueIfNull(Object.Category, ""));
-                                dbDict.Add("version", Common.ReturnValueIfNull(Object.Version, ""));
-                                dbDict.Add("author", Common.ReturnValueIfNull(Object.Author, ""));
-                                dbDict.Add("email", Common.ReturnValueIfNull(Object.Email, ""));
-                                dbDict.Add("homepage", Common.ReturnValueIfNull(Object.Homepage, ""));
-                                dbDict.Add("uri", sourceUriStr);
-                                dbDict.Add("sourcetype", Common.ReturnValueIfNull(Object.SourceType, ""));
-                                dbDict.Add("sourcemd5", Object.SourceMd5);
-                                dbDict.Add("sourcesha1", Object.SourceSHA1);
+                            }
+                            break;
+                    }
+                }
+
+                // check xml file md5
+                Common.hashObject hashObject = new Common.hashObject(XMLFile);
+                sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
+                dbDict = new Dictionary<string, object>();
+                dbDict.Add("sourcemd5", hashObject.md5hash);
+                sigDB = db.ExecuteCMD(sql, dbDict);
+
+                if (sigDB.Rows.Count == 0)
+                {
+                    try
+                    {
+                        // start parsing file
+                        gaseous_signature_parser.parser Parser = new gaseous_signature_parser.parser();
+                        RomSignatureObject Object = Parser.ParseSignatureDAT(XMLFile, DBFile, XMLType);
+
+                        // store in database
+                        string[] flipNameAndDescription = {
+                            "MAMEArcade",
+                            "MAMEMess"
+                        };
+
+                        // store source object
+                        bool processGames = false;
+                        if (Object.SourceMd5 != null)
+                        {
+                            int sourceId = 0;
+
+                            sql = "SELECT * FROM Signatures_Sources WHERE `SourceMD5`=@sourcemd5";
+                            dbDict = new Dictionary<string, object>
+                            {
+                                { "name", Common.ReturnValueIfNull(Object.Name, "") },
+                                { "description", Common.ReturnValueIfNull(Object.Description, "") },
+                                { "category", Common.ReturnValueIfNull(Object.Category, "") },
+                                { "version", Common.ReturnValueIfNull(Object.Version, "") },
+                                { "author", Common.ReturnValueIfNull(Object.Author, "") },
+                                { "email", Common.ReturnValueIfNull(Object.Email, "") },
+                                { "homepage", Common.ReturnValueIfNull(Object.Homepage, "") }
+                            };
+                            if (Object.Url == null)
+                            {
+                                dbDict.Add("uri", "");
+                            }
+                            else
+                            {
+                                dbDict.Add("uri", Common.ReturnValueIfNull(Object.Url.ToString(), ""));
+                            }
+                            dbDict.Add("sourcetype", Common.ReturnValueIfNull(Object.SourceType, ""));
+                            dbDict.Add("sourcemd5", Object.SourceMd5);
+                            dbDict.Add("sourcesha1", Object.SourceSHA1);
+
+                            sigDB = db.ExecuteCMD(sql, dbDict);
+                            if (sigDB.Rows.Count == 0)
+                            {
+                                // entry not present, insert it
+                                sql = "INSERT INTO Signatures_Sources (`Name`, `Description`, `Category`, `Version`, `Author`, `Email`, `Homepage`, `Url`, `SourceType`, `SourceMD5`, `SourceSHA1`) VALUES (@name, @description, @category, @version, @author, @email, @homepage, @uri, @sourcetype, @sourcemd5, @sourcesha1); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";

                                sigDB = db.ExecuteCMD(sql, dbDict);
-                                if (sigDB.Rows.Count == 0)
+
+                                sourceId = Convert.ToInt32(sigDB.Rows[0][0]);
+
+                                processGames = true;
+                            }
+
+                            if (processGames == true)
+                            {
+                                for (int x = 0; x < Object.Games.Count; ++x)
                                {
-                                    // entry not present, insert it
-                                    sql = "INSERT INTO Signatures_Sources (Name, Description, Category, Version, Author, Email, Homepage, Url, SourceType, SourceMD5, SourceSHA1) VALUES (@name, @description, @category, @version, @author, @email, @homepage, @uri, @sourcetype, @sourcemd5, @sourcesha1)";
+                                    RomSignatureObject.Game gameObject = Object.Games[x];

-                                    db.ExecuteCMD(sql, dbDict);
-
-                                    processGames = true;
-                                }
-
-                                if (processGames == true)
-                                {
-                                    for (int x = 0; x < Object.Games.Count; ++x)
+                                    // set up game dictionary
+                                    dbDict = new Dictionary<string, object>();
+                                    if (flipNameAndDescription.Contains(Object.SourceType))
                                    {
-                                        RomSignatureObject.Game gameObject = Object.Games[x];
+                                        dbDict.Add("name", Common.ReturnValueIfNull(gameObject.Description, ""));
+                                        dbDict.Add("description", Common.ReturnValueIfNull(gameObject.Name, ""));
+                                    }
+                                    else
+                                    {
+                                        dbDict.Add("name", Common.ReturnValueIfNull(gameObject.Name, ""));
+                                        dbDict.Add("description", Common.ReturnValueIfNull(gameObject.Description, ""));
+                                    }
+                                    dbDict.Add("year", Common.ReturnValueIfNull(gameObject.Year, ""));
+                                    dbDict.Add("publisher", Common.ReturnValueIfNull(gameObject.Publisher, ""));
+                                    dbDict.Add("demo", (int)gameObject.Demo);
+                                    dbDict.Add("system", Common.ReturnValueIfNull(gameObject.System, ""));
+                                    dbDict.Add("platform", Common.ReturnValueIfNull(gameObject.System, ""));
+                                    dbDict.Add("systemvariant", Common.ReturnValueIfNull(gameObject.SystemVariant, ""));
+                                    dbDict.Add("video", Common.ReturnValueIfNull(gameObject.Video, ""));

-                                        // set up game dictionary
-                                        dbDict = new Dictionary<string, object>();
-                                        if (flipNameAndDescription.Contains(Object.SourceType)) 
+                                    List<int> gameCountries = new List<int>();
+                                    if (
+                                        gameObject.Country != null &&
+                                        gameObject.Country != "Unknown"
+                                        )
+                                    {
+                                        string[] countries = gameObject.Country.Split(",");
+                                        foreach (string country in countries)
                                        {
-                                            dbDict.Add("name", Common.ReturnValueIfNull(gameObject.Description, ""));
-                                            dbDict.Add("description", Common.ReturnValueIfNull(gameObject.Name, ""));
-                                        }
-                                        else
-                                        {
-                                            dbDict.Add("name", Common.ReturnValueIfNull(gameObject.Name, ""));
-                                            dbDict.Add("description", Common.ReturnValueIfNull(gameObject.Description, ""));
-                                        }
-                                        dbDict.Add("year", Common.ReturnValueIfNull(gameObject.Year, ""));
-                                        dbDict.Add("publisher", Common.ReturnValueIfNull(gameObject.Publisher, ""));
-                                        dbDict.Add("demo", (int)gameObject.Demo);
-                                        dbDict.Add("system", Common.ReturnValueIfNull(gameObject.System, ""));
-                                        dbDict.Add("platform", Common.ReturnValueIfNull(gameObject.System, ""));
-                                        dbDict.Add("systemvariant", Common.ReturnValueIfNull(gameObject.SystemVariant, ""));
-                                        dbDict.Add("video", Common.ReturnValueIfNull(gameObject.Video, ""));
-                                        dbDict.Add("country", Common.ReturnValueIfNull(gameObject.Country, ""));
-                                        dbDict.Add("language", Common.ReturnValueIfNull(gameObject.Language, ""));
-                                        dbDict.Add("copyright", Common.ReturnValueIfNull(gameObject.Copyright, ""));
-
-                                        // store platform
-                                        int gameSystem = 0;
-                                        if (gameObject.System != null)
-                                        {
-                                            sql = "SELECT Id FROM Signatures_Platforms WHERE Platform=@platform";
-
-                                            sigDB = db.ExecuteCMD(sql, dbDict);
-                                            if (sigDB.Rows.Count == 0)
+                                            int countryId = -1;
+                                            countryId = Common.GetLookupByCode(Common.LookupTypes.Country, (string)Common.ReturnValueIfNull(country.Trim(), ""));
+                                            if (countryId == -1)
                                            {
-                                                // entry not present, insert it
-                                                sql = "INSERT INTO Signatures_Platforms (Platform) VALUES (@platform); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
-                                                sigDB = db.ExecuteCMD(sql, dbDict);
+                                                countryId = Common.GetLookupByValue(Common.LookupTypes.Country, (string)Common.ReturnValueIfNull(country.Trim(), ""));

-                                                gameSystem = Convert.ToInt32(sigDB.Rows[0][0]);
+                                                if (countryId == -1)
+                                                {
+                                                    Logging.Log(Logging.LogType.Warning, "Signature Ingest", "Unable to locate country id for " + country.Trim());
+                                                    sql = "INSERT INTO Country (`Code`, `Value`) VALUES (@code, @name); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                                    Dictionary<string, object> countryDict = new Dictionary<string, object>{
+                                                        { "code", country.Trim() },
+                                                        { "name", country.Trim() }
+                                                    };
+                                                    countryId = int.Parse(db.ExecuteCMD(sql, countryDict).Rows[0][0].ToString());
+                                                }
                                            }
-                                            else
+
+                                            if (countryId > 0)
                                            {
-                                                gameSystem = (int)sigDB.Rows[0][0];
+                                                gameCountries.Add(countryId);
                                            }
                                        }
-                                        dbDict.Add("systemid", gameSystem);
+                                    }

-                                        // store publisher
-                                        int gamePublisher = 0;
-                                        if (gameObject.Publisher != null)
+                                    List<int> gameLanguages = new List<int>();
+                                    if (
+                                        gameObject.Language != null &&
+                                        gameObject.Language != "nolang"
+                                        )
+                                    {
+                                        string[] languages = gameObject.Language.Split(",");
+                                        foreach (string language in languages)
                                        {
-                                            sql = "SELECT * FROM Signatures_Publishers WHERE Publisher=@publisher";
+                                            int languageId = -1;
+                                            languageId = Common.GetLookupByCode(Common.LookupTypes.Language, (string)Common.ReturnValueIfNull(language.Trim(), ""));
+                                            if (languageId == -1)
+                                            {
+                                                languageId = Common.GetLookupByValue(Common.LookupTypes.Language, (string)Common.ReturnValueIfNull(language.Trim(), ""));

-                                            sigDB = db.ExecuteCMD(sql, dbDict);
-                                            if (sigDB.Rows.Count == 0)
-                                            {
-                                                // entry not present, insert it
-                                                sql = "INSERT INTO Signatures_Publishers (Publisher) VALUES (@publisher); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
-                                                sigDB = db.ExecuteCMD(sql, dbDict);
-                                                gamePublisher = Convert.ToInt32(sigDB.Rows[0][0]);
+                                                if (languageId == -1)
+                                                {
+                                                    Logging.Log(Logging.LogType.Warning, "Signature Ingest", "Unable to locate language id for " + language.Trim());
+                                                    sql = "INSERT INTO Language (`Code`, `Value`) VALUES (@code, @name); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                                    Dictionary<string, object> langDict = new Dictionary<string, object>{
+                                                        { "code", language.Trim() },
+                                                        { "name", language.Trim() }
+                                                    };
+                                                    languageId = int.Parse(db.ExecuteCMD(sql, langDict).Rows[0][0].ToString());
+                                                }
                                            }
-                                            else
+
+                                            if (languageId > 0)
                                            {
-                                                gamePublisher = (int)sigDB.Rows[0][0];
+                                                gameLanguages.Add(languageId);
                                            }
                                        }
-                                        dbDict.Add("publisherid", gamePublisher);
+                                    }

-                                        // store game
-                                        int gameId = 0;
-                                        sql = "SELECT * FROM Signatures_Games WHERE Name=@name AND Year=@year AND Publisherid=@publisher AND Systemid=@systemid AND Country=@country AND Language=@language";
+                                    dbDict.Add("copyright", Common.ReturnValueIfNull(gameObject.Copyright, ""));
+
+                                    // store platform
+                                    int gameSystem = 0;
+                                    if (gameObject.System != null)
+                                    {
+                                        sql = "SELECT `Id` FROM Signatures_Platforms WHERE `Platform`=@platform";

                                        sigDB = db.ExecuteCMD(sql, dbDict);
                                        if (sigDB.Rows.Count == 0)
                                        {
                                            // entry not present, insert it
-                                            sql = "INSERT INTO Signatures_Games " +
-                                                "(Name, Description, Year, PublisherId, Demo, SystemId, SystemVariant, Video, Country, Language, Copyright) VALUES " +
-                                                "(@name, @description, @year, @publisherid, @demo, @systemid, @systemvariant, @video, @country, @language, @copyright); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                            sql = "INSERT INTO Signatures_Platforms (`Platform`) VALUES (@platform); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
                                            sigDB = db.ExecuteCMD(sql, dbDict);

-                                            gameId = Convert.ToInt32(sigDB.Rows[0][0]);
+                                            gameSystem = Convert.ToInt32(sigDB.Rows[0][0]);
                                        }
                                        else
                                        {
-                                            gameId = (int)sigDB.Rows[0][0];
+                                            gameSystem = (int)sigDB.Rows[0][0];
                                        }
+                                    }
+                                    dbDict.Add("systemid", gameSystem);

-                                        // store rom
-                                        foreach (RomSignatureObject.Game.Rom romObject in gameObject.Roms)
+                                    // store publisher
+                                    int gamePublisher = 0;
+                                    if (gameObject.Publisher != null)
+                                    {
+                                        sql = "SELECT * FROM Signatures_Publishers WHERE `Publisher`=@publisher";
+
+                                        sigDB = db.ExecuteCMD(sql, dbDict);
+                                        if (sigDB.Rows.Count == 0)
                                        {
-                                            if (romObject.Md5 != null || romObject.Sha1 != null)
+                                            // entry not present, insert it
+                                            sql = "INSERT INTO Signatures_Publishers (`Publisher`) VALUES (@publisher); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                            sigDB = db.ExecuteCMD(sql, dbDict);
+                                            gamePublisher = Convert.ToInt32(sigDB.Rows[0][0]);
+                                        }
+                                        else
+                                        {
+                                            gamePublisher = (int)sigDB.Rows[0][0];
+                                        }
+                                    }
+                                    dbDict.Add("publisherid", gamePublisher);
+
+                                    // store game
+                                    long gameId = 0;
+                                    sql = "SELECT * FROM Signatures_Games WHERE `Name`=@name AND `Year`=@year AND `PublisherId`=@publisherid AND `SystemId`=@systemid";
+
+                                    sigDB = db.ExecuteCMD(sql, dbDict);
+                                    if (sigDB.Rows.Count == 0)
+                                    {
+                                        // entry not present, insert it
+                                        sql = "INSERT INTO Signatures_Games " +
+                                            "(`Name`, `Description`, `Year`, `PublisherId`, `Demo`, `SystemId`, `SystemVariant`, `Video`, `Copyright`) VALUES " +
+                                            "(@name, @description, @year, @publisherid, @demo, @systemid, @systemvariant, @video, @copyright); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                        sigDB = db.ExecuteCMD(sql, dbDict);
+
+                                        gameId = Convert.ToInt32(sigDB.Rows[0][0]);
+                                    }
+                                    else
+                                    {
+                                        gameId = (int)sigDB.Rows[0][0];
+                                    }
+
+                                    // insert countries
+                                    foreach (int gameCountry in gameCountries)
+                                    {
+                                        try
+                                        {
+                                            sql = "SELECT * FROM Signatures_Games_Countries WHERE GameId = @gameid AND CountryId = @Countryid";
+                                            Dictionary<string, object> countryDict = new Dictionary<string, object>{
+                                                { "gameid", gameId },
+                                                { "Countryid", gameCountry }
+                                            };
+                                            if (db.ExecuteCMD(sql, countryDict).Rows.Count == 0)
                                            {
-                                                int romId = 0;
-                                                sql = "SELECT * FROM Signatures_Roms WHERE GameId=@gameid AND MD5=@md5";
-                                                dbDict = new Dictionary<string, object>();
-                                                dbDict.Add("gameid", gameId);
-                                                dbDict.Add("name", Common.ReturnValueIfNull(romObject.Name, ""));
-                                                dbDict.Add("size", Common.ReturnValueIfNull(romObject.Size, ""));
-                                                dbDict.Add("crc", Common.ReturnValueIfNull(romObject.Crc, "").ToString().ToLower());
-                                                dbDict.Add("md5", Common.ReturnValueIfNull(romObject.Md5, "").ToString().ToLower());
-                                                dbDict.Add("sha1", Common.ReturnValueIfNull(romObject.Sha1, "").ToString().ToLower());
-                                                dbDict.Add("developmentstatus", Common.ReturnValueIfNull(romObject.DevelopmentStatus, ""));
+                                                sql = "INSERT INTO Signatures_Games_Countries (GameId, CountryId) VALUES (@gameid, @Countryid)";
+                                                db.ExecuteCMD(sql, countryDict);
+                                            }
+                                        }
+                                        catch
+                                        {
+                                            Console.WriteLine("Game id: " + gameId + " with Country " + gameCountry);
+                                        }
+                                    }

-                                                if (romObject.Attributes != null)
+                                    // insert languages
+                                    foreach (int gameLanguage in gameLanguages)
+                                    {
+                                        try
+                                        {
+                                            sql = "SELECT * FROM Signatures_Games_Languages WHERE GameId = @gameid AND LanguageId = @languageid";
+                                            Dictionary<string, object> langDict = new Dictionary<string, object>{
+                                                { "gameid", gameId },
+                                                { "languageid", gameLanguage }
+                                            };
+                                            if (db.ExecuteCMD(sql, langDict).Rows.Count == 0)
+                                            {
+                                                sql = "INSERT INTO Signatures_Games_Languages (GameId, LanguageId) VALUES (@gameid, @languageid)";
+                                                db.ExecuteCMD(sql, langDict);
+                                            }
+                                        }
+                                        catch
+                                        {
+                                            Console.WriteLine("Game id: " + gameId + " with language " + gameLanguage);
+                                        }
+                                    }
+
+                                    // store rom
+                                    foreach (RomSignatureObject.Game.Rom romObject in gameObject.Roms)
+                                    {
+                                        if (romObject.Md5 != null || romObject.Sha1 != null)
+                                        {
+                                            long romId = 0;
+                                            sql = "SELECT * FROM Signatures_Roms WHERE `GameId`=@gameid AND (`MD5`=@md5 OR `SHA1`=@sha1)";
+                                            dbDict = new Dictionary<string, object>();
+                                            dbDict.Add("gameid", gameId);
+                                            dbDict.Add("name", Common.ReturnValueIfNull(romObject.Name, ""));
+                                            dbDict.Add("size", Common.ReturnValueIfNull(romObject.Size, ""));
+                                            dbDict.Add("crc", Common.ReturnValueIfNull(romObject.Crc, "").ToString().ToLower());
+                                            dbDict.Add("md5", Common.ReturnValueIfNull(romObject.Md5, "").ToString().ToLower());
+                                            dbDict.Add("sha1", Common.ReturnValueIfNull(romObject.Sha1, "").ToString().ToLower());
+                                            dbDict.Add("developmentstatus", Common.ReturnValueIfNull(romObject.DevelopmentStatus, ""));
+
+                                            if (romObject.Attributes != null)
+                                            {
+                                                if (romObject.Attributes.Count > 0)
                                                {
-                                                    if (romObject.Attributes.Count > 0)
-                                                    {
-                                                        dbDict.Add("attributes", Newtonsoft.Json.JsonConvert.SerializeObject(romObject.Attributes));
-                                                    }
-                                                    else
-                                                    {
-                                                        dbDict.Add("attributes", "[ ]");
-                                                    }
+                                                    dbDict.Add("attributes", Newtonsoft.Json.JsonConvert.SerializeObject(romObject.Attributes));
                                                }
                                                else
                                                {
-                                                    dbDict.Add("attributes", "[ ]");
+                                                    dbDict.Add("attributes", "");
                                                }
-                                                dbDict.Add("romtype", (int)romObject.RomType);
-                                                dbDict.Add("romtypemedia", Common.ReturnValueIfNull(romObject.RomTypeMedia, ""));
-                                                dbDict.Add("medialabel", Common.ReturnValueIfNull(romObject.MediaLabel, ""));
-                                                dbDict.Add("metadatasource", romObject.SignatureSource);
-                                                dbDict.Add("ingestorversion", 2);
+                                            }
+                                            else
+                                            {
+                                                dbDict.Add("attributes", "");
+                                            }
+                                            dbDict.Add("romtype", (int)romObject.RomType);
+                                            dbDict.Add("romtypemedia", Common.ReturnValueIfNull(romObject.RomTypeMedia, ""));
+                                            dbDict.Add("medialabel", Common.ReturnValueIfNull(romObject.MediaLabel, ""));
+                                            dbDict.Add("metadatasource", romObject.SignatureSource);
+                                            dbDict.Add("ingestorversion", 2);

+                                            sigDB = db.ExecuteCMD(sql, dbDict);
+                                            if (sigDB.Rows.Count == 0)
+                                            {
+                                                // entry not present, insert it
+                                                sql = "INSERT INTO Signatures_Roms (`GameId`, `Name`, `Size`, `CRC`, `MD5`, `SHA1`, `DevelopmentStatus`, `Attributes`, `RomType`, `RomTypeMedia`, `MediaLabel`, `MetadataSource`, `IngestorVersion`) VALUES (@gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @attributes, @romtype, @romtypemedia, @medialabel, @metadatasource, @ingestorversion); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
                                                sigDB = db.ExecuteCMD(sql, dbDict);
-                                                if (sigDB.Rows.Count == 0)
-                                                {
-                                                    // entry not present, insert it
-                                                    sql = "INSERT INTO Signatures_Roms (GameId, Name, Size, CRC, MD5, SHA1, DevelopmentStatus, Attributes, RomType, RomTypeMedia, MediaLabel, MetadataSource, IngestorVersion) VALUES (@gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @attributes, @romtype, @romtypemedia, @medialabel, @metadatasource, @ingestorversion); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
-                                                    sigDB = db.ExecuteCMD(sql, dbDict);

+                                                romId = Convert.ToInt32(sigDB.Rows[0][0]);
+                                            }
+                                            else
+                                            {
+                                                romId = (int)sigDB.Rows[0][0];
+                                            }

-                                                    romId = Convert.ToInt32(sigDB.Rows[0][0]);
-                                                }
-                                                else
-                                                {
-                                                    romId = (int)sigDB.Rows[0][0];
-                                                }
+                                            // map the rom to the source
+                                            sql = "SELECT * FROM Signatures_RomToSource WHERE SourceId=@sourceid AND RomId=@romid;";
+                                            dbDict.Add("romid", romId);
+                                            dbDict.Add("sourceId", sourceId);
+
+                                            sigDB = db.ExecuteCMD(sql, dbDict);
+                                            if (sigDB.Rows.Count == 0)
+                                            {
+                                                sql = "INSERT INTO Signatures_RomToSource (`SourceId`, `RomId`) VALUES (@sourceid, @romid);";
+                                                db.ExecuteCMD(sql, dbDict);
                                            }
                                        }
                                    }
                                }
                            }
                        }
-                        catch (Exception ex)
+
+                        File.Move(XMLFile, Path.Combine(ProcessedDirectory, Path.GetFileName(XMLFile)));
+                        if (DBFile != null)
                        {
-                            Logging.Log(Logging.LogType.Warning, "Signature Ingestor - XML", "Invalid import file: " + XMLFile, ex);
+                            File.Move(DBFile, Path.Combine(XMLDBProcessedDirectory, Path.GetFileName(DBFile)));
                        }
                    }
-                    else
+                    catch (Exception ex)
                    {
-                        Logging.Log(Logging.LogType.Debug, "Signature Ingestor - XML", "Rejecting already imported file: " + XMLFile);
+                        Logging.Log(Logging.LogType.Warning, "Signature Ingest", "Error ingesting " + XMLType.ToString() + " file: " + XMLFile, ex);
+                    }
+                }
+                else
+                {
+                    Logging.Log(Logging.LogType.Information, "Signature Ingest", "Rejecting already imported " + XMLType.ToString() + " file: " + XMLFile);
+                    File.Move(XMLFile, Path.Combine(ProcessedDirectory, Path.GetFileName(XMLFile)));
+                    if (DBFile != null)
+                    {
+                        File.Move(DBFile, Path.Combine(XMLDBProcessedDirectory, Path.GetFileName(DBFile)));
                    }
                }
            }
--- a/gaseous-server/Classes/SignatureManagement.cs
+++ b/gaseous-server/Classes/SignatureManagement.cs
@@ -1,5 +1,7 @@
 using System.Data;
+using gaseous_server.Models;
 using gaseous_signature_parser.models.RomSignatureObject;
+using static gaseous_server.Classes.Common;

 namespace gaseous_server.Classes
 {
@@ -10,7 +12,8 @@ namespace gaseous_server.Classes
            if (md5.Length > 0)
            {
                return _GetSignature("Signatures_Roms.md5 = @searchstring", md5);
-            } else
+            }
+            else
            {
                return _GetSignature("Signatures_Roms.sha1 = @searchstring", sha1);
            }
@@ -21,7 +24,8 @@ namespace gaseous_server.Classes
            if (TosecName.Length > 0)
            {
                return _GetSignature("Signatures_Roms.name = @searchstring", TosecName);
-            } else
+            }
+            else
            {
                return null;
            }
@@ -44,7 +48,7 @@ namespace gaseous_server.Classes
                {
                    Game = new gaseous_server.Models.Signatures_Games.GameItem
                    {
-                        Id = (Int32)sigDbRow["Id"],
+                        Id = (long)(int)sigDbRow["Id"],
                        Name = (string)sigDbRow["Name"],
                        Description = (string)sigDbRow["Description"],
                        Year = (string)sigDbRow["Year"],
@@ -53,20 +57,20 @@ namespace gaseous_server.Classes
                        System = (string)sigDbRow["Platform"],
                        SystemVariant = (string)sigDbRow["SystemVariant"],
                        Video = (string)sigDbRow["Video"],
-                        Country = (string)sigDbRow["Country"],
-                        Language = (string)sigDbRow["Language"],
+                        Countries = new Dictionary<string, string>(GetLookup(LookupTypes.Country, (long)(int)sigDbRow["Id"])),
+                        Languages = new Dictionary<string, string>(GetLookup(LookupTypes.Language, (long)(int)sigDbRow["Id"])),
                        Copyright = (string)sigDbRow["Copyright"]
                    },
                    Rom = new gaseous_server.Models.Signatures_Games.RomItem
                    {
-                        Id = (Int32)sigDbRow["romid"],
+                        Id = (long)(int)sigDbRow["romid"],
                        Name = (string)sigDbRow["romname"],
                        Size = (Int64)sigDbRow["Size"],
                        Crc = (string)sigDbRow["CRC"],
                        Md5 = ((string)sigDbRow["MD5"]).ToLower(),
                        Sha1 = ((string)sigDbRow["SHA1"]).ToLower(),
                        DevelopmentStatus = (string)sigDbRow["DevelopmentStatus"],
-                        Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<List<KeyValuePair<string, object>>>((string)Common.ReturnValueIfNull(sigDbRow["Attributes"], "[]")),
+                        Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>((string)Common.ReturnValueIfNull(sigDbRow["Attributes"], "[]")),
                        RomType = (gaseous_server.Models.Signatures_Games.RomItem.RomTypes)(int)sigDbRow["RomType"],
                        RomTypeMedia = (string)sigDbRow["RomTypeMedia"],
                        MediaLabel = (string)sigDbRow["MediaLabel"],
@@ -77,5 +81,77 @@ namespace gaseous_server.Classes
            }
            return GamesList;
        }
+
+        public List<Signatures_Sources> GetSources()
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM Signatures_Sources ORDER BY `SourceType`, `Name`;";
+            DataTable sigDb = db.ExecuteCMD(sql);
+
+            List<Signatures_Sources> SourcesList = new List<Signatures_Sources>();
+
+            foreach (DataRow sigDbRow in sigDb.Rows)
+            {
+                Signatures_Sources sourceItem = new Signatures_Sources
+                {
+                    Id = (int)sigDbRow["Id"],
+                    Name = (string)sigDbRow["Name"],
+                    Description = (string)sigDbRow["Description"],
+                    URL = (string)sigDbRow["URL"],
+                    Category = (string)sigDbRow["Category"],
+                    Version = (string)sigDbRow["Version"],
+                    Author = (string)sigDbRow["Author"],
+                    Email = (string)sigDbRow["Email"],
+                    Homepage = (string)sigDbRow["Homepage"],
+                    SourceType = (gaseous_signature_parser.parser.SignatureParser)Enum.Parse(typeof(gaseous_signature_parser.parser.SignatureParser), sigDbRow["SourceType"].ToString()),
+                    MD5 = (string)sigDbRow["SourceMD5"],
+                    SHA1 = (string)sigDbRow["SourceSHA1"]
+                };
+                SourcesList.Add(sourceItem);
+            }
+            return SourcesList;
+        }
+
+        public void DeleteSource(int sourceId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM Signatures_Sources WHERE Id = @sourceId;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "sourceId", sourceId }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public Dictionary<string, string> GetLookup(LookupTypes LookupType, long GameId)
+        {
+            string tableName = "";
+            switch (LookupType)
+            {
+                case LookupTypes.Country:
+                    tableName = "Countries";
+                    break;
+
+                case LookupTypes.Language:
+                    tableName = "Languages";
+                    break;
+
+            }
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT " + LookupType.ToString() + ".Code, " + LookupType.ToString() + ".Value FROM Signatures_Games_" + tableName + " JOIN " + LookupType.ToString() + " ON Signatures_Games_" + tableName + "." + LookupType.ToString() + "Id = " + LookupType.ToString() + ".Id WHERE Signatures_Games_" + tableName + ".GameId = @id;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "id", GameId }
+            };
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            Dictionary<string, string> returnDict = new Dictionary<string, string>();
+            foreach (DataRow row in data.Rows)
+            {
+                returnDict.Add((string)row["Code"], (string)row["Value"]);
+            }
+
+            return returnDict;
+        }
    }
 }
--- a/gaseous-server/Classes/Statistics.cs
+++ b/gaseous-server/Classes/Statistics.cs
@@ -5,29 +5,45 @@ namespace gaseous_server.Classes
 {
    public class Statistics
    {
-        public StatisticsModel RecordSession(Guid SessionId, long GameId, string UserId)
+        public StatisticsModel RecordSession(Guid SessionId, long GameId, long PlatformId, long RomId, bool IsMediaGroup, string UserId)
        {
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
            string sql;
-            Dictionary<string, object> dbDict;
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "userid", UserId },
+                { "gameid", GameId },
+                { "platformid", PlatformId },
+                { "romid", RomId },
+                { "ismediagroup", IsMediaGroup }
+            };
+
+            // update last played rom id
+            sql = "INSERT INTO User_RecentPlayedRoms (UserId, GameId, PlatformId, RomId, IsMediaGroup) VALUES (@userid, @gameid, @platformid, @romid, @ismediagroup) ON DUPLICATE KEY UPDATE RomId = @romid, IsMediaGroup = @ismediagroup;";
+            db.ExecuteNonQuery(sql, dbDict);
+
+            // update sessions

            if (SessionId == Guid.Empty)
            {
                // new session required
                SessionId = Guid.NewGuid();

-                sql = "INSERT INTO UserTimeTracking (GameId, UserId, SessionId, SessionTime, SessionLength) VALUES (@gameid, @userid, @sessionid, @sessiontime, @sessionlength);";
+                sql = "INSERT INTO UserTimeTracking (GameId, UserId, SessionId, SessionTime, SessionLength, PlatformId, IsMediaGroup, RomId) VALUES (@gameid, @userid, @sessionid, @sessiontime, @sessionlength, @platformid, @ismediagroup, @romid);";
                dbDict = new Dictionary<string, object>{
                    { "gameid", GameId },
                    { "userid", UserId },
                    { "sessionid", SessionId },
                    { "sessiontime", DateTime.UtcNow },
-                    { "sessionlength", 1 }
+                    { "sessionlength", 1 },
+                    { "platformid", PlatformId },
+                    { "ismediagroup", IsMediaGroup },
+                    { "romid", RomId }
                };

                db.ExecuteNonQuery(sql, dbDict);

-                return new StatisticsModel{
+                return new StatisticsModel
+                {
                    GameId = GameId,
                    SessionId = SessionId,
                    SessionStart = (DateTime)dbDict["sessiontime"],
@@ -50,7 +66,8 @@ namespace gaseous_server.Classes
                sql = "SELECT * FROM UserTimeTracking WHERE GameId = @gameid AND UserId = @userid AND SessionId = @sessionid;";
                DataTable data = db.ExecuteCMD(sql, dbDict);

-                return new StatisticsModel{
+                return new StatisticsModel
+                {
                    GameId = (long)data.Rows[0]["GameId"],
                    SessionId = Guid.Parse(data.Rows[0]["SessionId"].ToString()),
                    SessionStart = (DateTime)data.Rows[0]["SessionTime"],
@@ -87,7 +104,8 @@ namespace gaseous_server.Classes
                    sql = "SELECT * FROM UserTimeTracking WHERE GameId = @gameid AND UserId = @userid ORDER BY SessionTime DESC LIMIT 1;";
                    data = db.ExecuteCMD(sql, dbDict);

-                    return new StatisticsModel{
+                    return new StatisticsModel
+                    {
                        GameId = GameId,
                        SessionLength = TotalTime,
                        SessionStart = (DateTime)data.Rows[0]["SessionTime"]
--- a/gaseous-server/Classes/UserProfile.cs
+++ b/gaseous-server/Classes/UserProfile.cs
@@ -0,0 +1,187 @@
+using System.Data;
+
+namespace gaseous_server.Classes
+{
+    public class UserProfile
+    {
+        static readonly Dictionary<string, string> supportedImages = new Dictionary<string, string>{
+            { ".png", "image/png" },
+            { ".jpg", "image/jpeg" },
+            { ".jpeg", "image/jpeg" },
+            { ".gif", "image/gif" },
+            { ".bmp", "image/bmp" },
+            { ".svg", "image/svg+xml" }
+        };
+
+        public Models.UserProfile? GetUserProfile(string UserId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT Id, DisplayName, Quip, AvatarExtension, ProfileBackgroundExtension, UnstructuredData FROM UserProfiles WHERE Id = @userid;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "userid", UserId }
+            };
+
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            if (data.Rows.Count == 0)
+            {
+                return null;
+            }
+
+            Models.UserProfile.ProfileImageItem? Avatar = null;
+            if (data.Rows[0]["AvatarExtension"] != DBNull.Value)
+            {
+                Avatar = new Models.UserProfile.ProfileImageItem
+                {
+                    MimeType = supportedImages[data.Rows[0]["AvatarExtension"].ToString()],
+                    Extension = data.Rows[0]["AvatarExtension"].ToString()
+                };
+            }
+
+            Models.UserProfile.ProfileImageItem? ProfileBackground = null;
+            if (data.Rows[0]["ProfileBackgroundExtension"] != DBNull.Value)
+            {
+                ProfileBackground = new Models.UserProfile.ProfileImageItem
+                {
+                    MimeType = supportedImages[data.Rows[0]["ProfileBackgroundExtension"].ToString()],
+                    Extension = data.Rows[0]["ProfileBackgroundExtension"].ToString()
+                };
+            }
+
+            return new Models.UserProfile
+            {
+                UserId = Guid.Parse(data.Rows[0]["Id"].ToString()),
+                DisplayName = data.Rows[0]["DisplayName"].ToString(),
+                Quip = data.Rows[0]["Quip"].ToString(),
+                Avatar = Avatar,
+                ProfileBackground = ProfileBackground,
+                Data = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(data.Rows[0]["UnstructuredData"].ToString())
+            };
+        }
+
+        public void UpdateUserProfile(string InternalUserId, Models.UserProfile profile)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "UPDATE UserProfiles SET DisplayName = @displayname, Quip = @quip, UnstructuredData = @data WHERE UserId = @internalId AND Id = @userid;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "displayname", profile.DisplayName },
+                { "quip", profile.Quip },
+                { "data", Newtonsoft.Json.JsonConvert.SerializeObject(profile.Data) },
+                { "userid", profile.UserId },
+                { "internalId", InternalUserId }
+            };
+
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public enum ImageType
+        {
+            Avatar,
+            Background
+        }
+
+        public void UpdateImage(ImageType imageType, string UserId, string InternalUserId, string Filename, byte[] bytes)
+        {
+            // check if it's a supported file type
+            if (!supportedImages.ContainsKey(Path.GetExtension(Filename).ToLower()))
+            {
+                throw new Exception("File type not supported");
+            }
+
+            string ByteFieldName;
+            string ExtensionFieldName;
+            switch (imageType)
+            {
+                case ImageType.Avatar:
+                    ByteFieldName = "Avatar";
+                    ExtensionFieldName = "AvatarExtension";
+                    break;
+                case ImageType.Background:
+                    ByteFieldName = "ProfileBackground";
+                    ExtensionFieldName = "ProfileBackgroundExtension";
+                    break;
+                default:
+                    throw new Exception("Invalid image type");
+            }
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = String.Format("UPDATE UserProfiles SET {0} = @content, {1} = @extension WHERE Id = @userid AND UserId = @internaluserid;", ByteFieldName, ExtensionFieldName);
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "content", bytes },
+                { "extension", Path.GetExtension(Filename) },
+                { "userid", UserId },
+                { "internaluserid", InternalUserId }
+            };
+
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public Models.ImageItem? GetImage(ImageType imageType, string UserId)
+        {
+            string ByteFieldName;
+            string ExtensionFieldName;
+            switch (imageType)
+            {
+                case ImageType.Avatar:
+                    ByteFieldName = "Avatar";
+                    ExtensionFieldName = "AvatarExtension";
+                    break;
+                case ImageType.Background:
+                    ByteFieldName = "ProfileBackground";
+                    ExtensionFieldName = "ProfileBackgroundExtension";
+                    break;
+                default:
+                    throw new Exception("Invalid image type");
+            }
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = String.Format("SELECT {0}, {1} FROM UserProfiles WHERE Id = @userid;", ByteFieldName, ExtensionFieldName);
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "userid", UserId }
+            };
+
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            if (data.Rows.Count == 0)
+            {
+                return null;
+            }
+
+            Models.ImageItem? image = new Models.ImageItem
+            {
+                content = data.Rows[0][ByteFieldName] as byte[],
+                mimeType = supportedImages[data.Rows[0][ExtensionFieldName] as string],
+                extension = data.Rows[0][ExtensionFieldName] as string
+            };
+
+            return image;
+        }
+
+        public void DeleteImage(ImageType imageType, string UserId)
+        {
+            string ByteFieldName;
+            string ExtensionFieldName;
+            switch (imageType)
+            {
+                case ImageType.Avatar:
+                    ByteFieldName = "Avatar";
+                    ExtensionFieldName = "AvatarExtension";
+                    break;
+                case ImageType.Background:
+                    ByteFieldName = "ProfileBackground";
+                    ExtensionFieldName = "ProfileBackgroundExtension";
+                    break;
+                default:
+                    throw new Exception("Invalid image type");
+            }
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = String.Format("UPDATE UserProfiles SET {0} = NULL, {1} = NULL WHERE UserId = @userid;", ByteFieldName, ExtensionFieldName);
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "userid", UserId }
+            };
+
+            db.ExecuteCMD(sql, dbDict);
+        }
+    }
+}
--- a/gaseous-server/Controllers/V1.0/AccountController.cs
+++ b/gaseous-server/Controllers/V1.0/AccountController.cs
@@ -99,7 +99,7 @@ namespace gaseous_server.Controllers
            profile.Roles = new List<string>(await _userManager.GetRolesAsync(user));
            profile.SecurityProfile = user.SecurityProfile;
            profile.UserPreferences = user.UserPreferences;
-            profile.Avatar = user.Avatar;
+            profile.ProfileId = user.ProfileId;
            profile.Roles.Sort();

            return Ok(profile);
@@ -188,7 +188,7 @@ namespace gaseous_server.Controllers
                user.LockoutEnabled = rawUser.LockoutEnabled;
                user.LockoutEnd = rawUser.LockoutEnd;
                user.SecurityProfile = rawUser.SecurityProfile;
-                user.Avatar = rawUser.Avatar;
+                user.ProfileId = rawUser.ProfileId;

                // get roles
                ApplicationUser? aUser = await _userManager.FindByIdAsync(rawUser.Id);
@@ -220,6 +220,10 @@ namespace gaseous_server.Controllers
                    Email = model.Email,
                    NormalizedEmail = model.Email.ToUpper()
                };
+                if (await _userManager.FindByEmailAsync(model.Email) != null)
+                {
+                    return NotFound("User already exists");
+                }
                var result = await _userManager.CreateAsync(user, model.Password);
                if (result.Succeeded)
                {
@@ -241,6 +245,23 @@ namespace gaseous_server.Controllers
            }
        }

+        [HttpGet]
+        [Route("Users/Test")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> TestUserExists(string Email)
+        {
+            ApplicationUser? rawUser = await _userManager.FindByEmailAsync(Email);
+
+            if (rawUser != null)
+            {
+                return Ok(true);
+            }
+            else
+            {
+                return Ok(false);
+            }
+        }
+
        [HttpGet]
        [Route("Users/{UserId}")]
        [Authorize(Roles = "Admin")]
@@ -256,6 +277,7 @@ namespace gaseous_server.Controllers
                user.LockoutEnabled = rawUser.LockoutEnabled;
                user.LockoutEnd = rawUser.LockoutEnd;
                user.SecurityProfile = rawUser.SecurityProfile;
+                user.ProfileId = rawUser.ProfileId;

                // get roles
                IList<string> aUserRoles = await _userManager.GetRolesAsync(rawUser);
@@ -306,7 +328,7 @@ namespace gaseous_server.Controllers
                // delete all roles
                foreach (string role in userRoles)
                {
-                    if ((new string[] { "Admin", "Gamer", "Player" }).Contains(role) )
+                    if ((new string[] { "Admin", "Gamer", "Player" }).Contains(role))
                    {
                        await _userManager.RemoveFromRoleAsync(user, role);
                    }
--- a/gaseous-server/Controllers/V1.0/BiosController.cs
+++ b/gaseous-server/Controllers/V1.0/BiosController.cs
@@ -7,6 +7,9 @@ using gaseous_server.Classes;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Asp.Versioning;
+using Authentication;
+using Microsoft.AspNetCore.Identity;
+using gaseous_server.Models;

 namespace gaseous_server.Controllers
 {
@@ -17,6 +20,15 @@ namespace gaseous_server.Controllers
    [Authorize]
    public class BiosController : Controller
    {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+
+        public BiosController(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager)
+        {
+            _userManager = userManager;
+            _signInManager = signInManager;
+        }
+
        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
        [HttpGet]
@@ -43,29 +55,59 @@ namespace gaseous_server.Controllers
        [MapToApiVersion("1.1")]
        [HttpHead]
        [Route("zip/{PlatformId}")]
+        [Route("zip/{PlatformId}/{GameId}")]
        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetBiosCompressed(long PlatformId)
+        public async Task<ActionResult> GetBiosCompressedAsync(long PlatformId, long GameId = -1, bool filtered = false)
        {
            try
            {
-                IGDB.Models.Platform platform = Classes.Metadata.Platforms.GetPlatform(PlatformId);
-
-                string biosPath = Path.Combine(Config.LibraryConfiguration.LibraryBIOSDirectory, platform.Slug);
-
-                string tempFile = Path.GetTempFileName();
-
-                using (FileStream zipFile = System.IO.File.Create(tempFile))
-                using (var zipArchive = new ZipArchive(zipFile, ZipArchiveMode.Create))
+                if (GameId == -1 || filtered == false)
                {
-                    foreach (string file in Directory.GetFiles(biosPath))
-                    {
-                        zipArchive.CreateEntryFromFile(file, Path.GetFileName(file));
-                    }
-                }
+                    IGDB.Models.Platform platform = Classes.Metadata.Platforms.GetPlatform(PlatformId);

-                var stream = new FileStream(tempFile, FileMode.Open);
-                return File(stream, "application/zip", platform.Slug + ".zip");
+                    string biosPath = Path.Combine(Config.LibraryConfiguration.LibraryBIOSDirectory, platform.Slug);
+
+                    string tempFile = Path.GetTempFileName();
+
+                    using (FileStream zipFile = System.IO.File.Create(tempFile))
+                    using (var zipArchive = new ZipArchive(zipFile, ZipArchiveMode.Create))
+                    {
+                        foreach (string file in Directory.GetFiles(biosPath))
+                        {
+                            zipArchive.CreateEntryFromFile(file, Path.GetFileName(file));
+                        }
+                    }
+
+                    var stream = new FileStream(tempFile, FileMode.Open);
+                    return File(stream, "application/zip", platform.Slug + ".zip");
+                }
+                else
+                {
+                    // get user platform map
+                    var user = await _userManager.GetUserAsync(User);
+
+                    PlatformMapping platformMapping = new PlatformMapping();
+                    PlatformMapping.PlatformMapItem userPlatformMap = platformMapping.GetUserPlatformMap(user.Id, PlatformId, GameId);
+
+                    // build zip file
+                    string tempFile = Path.GetTempFileName();
+
+                    using (FileStream zipFile = System.IO.File.Create(tempFile))
+                    using (var zipArchive = new ZipArchive(zipFile, ZipArchiveMode.Create))
+                    {
+                        foreach (Bios.BiosItem bios in GetBios(PlatformId, true))
+                        {
+                            if (userPlatformMap.EnabledBIOSHashes.Contains(bios.hash))
+                            {
+                                zipArchive.CreateEntryFromFile(bios.biosPath, bios.filename);
+                            }
+                        }
+                    }
+
+                    var stream = new FileStream(tempFile, FileMode.Open);
+                    return File(stream, "application/zip", userPlatformMap.IGDBSlug + ".zip");
+                }
            }
            catch
            {
--- a/gaseous-server/Controllers/V1.0/GamesController.cs
+++ b/gaseous-server/Controllers/V1.0/GamesController.cs
@@ -18,6 +18,7 @@ using Microsoft.AspNetCore.Mvc;
 using Microsoft.CodeAnalysis.Scripting;
 using static gaseous_server.Classes.Metadata.AgeRatings;
 using Asp.Versioning;
+using static gaseous_server.Models.PlatformMapping;

 namespace gaseous_server.Controllers
 {
@@ -53,7 +54,7 @@ namespace gaseous_server.Controllers
            int minrating = -1,
            int maxrating = -1,
            bool sortdescending = false)
-            {
+        {

            return Ok(GetGames(name, platform, genre, gamemode, playerperspective, theme, minrating, maxrating, "Adult", true, true, sortdescending));
        }
@@ -457,73 +458,6 @@ namespace gaseous_server.Controllers
            }
        }

-        [MapToApiVersion("1.0")]
-        [MapToApiVersion("1.1")]
-        [HttpGet]
-        [Route("{GameId}/artwork/{ArtworkId}/image/{size}")]
-        [Route("{GameId}/artwork/{ArtworkId}/image/{size}/{ImageName}")]
-        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public async Task<ActionResult> GameCoverImage(long GameId, long ArtworkId, Communications.IGDBAPI_ImageSize size, string ImageName)
-        {
-            try
-            {
-                IGDB.Models.Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);
-
-                try
-                {
-                    IGDB.Models.Artwork artworkObject = Artworks.GetArtwork(ArtworkId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), true);
-                    
-                    if (artworkObject != null) {
-                        //string coverFilePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), "Artwork", size.ToString(), artworkObject.ImageId + ".jpg");
-
-                        string basePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), "Artwork");
-
-                        Communications comms = new Communications();
-                        Task<string> ImgFetch = comms.GetSpecificImageFromServer(basePath, artworkObject.ImageId, size, new List<Communications.IGDBAPI_ImageSize>{ Communications.IGDBAPI_ImageSize.original });
-
-                        string coverFilePath = ImgFetch.Result;
-
-
-                        if (System.IO.File.Exists(coverFilePath))
-                        {
-                            string filename = artworkObject.ImageId + ".jpg";
-                            string filepath = coverFilePath;
-                            byte[] filedata = System.IO.File.ReadAllBytes(filepath);
-                            string contentType = "image/jpg";
-
-                            var cd = new System.Net.Mime.ContentDisposition
-                            {
-                                FileName = filename,
-                                Inline = true,
-                            };
-
-                            Response.Headers.Add("Content-Disposition", cd.ToString());
-                            Response.Headers.Add("Cache-Control", "public, max-age=604800");
-
-                            return File(filedata, contentType);
-                        }
-                        else
-                        {
-                            return NotFound();
-                        }
-                    }
-                    else
-                    {
-                        return NotFound();
-                    }
-                }
-                catch
-                {
-                    return NotFound();
-                }
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
-
        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
        [HttpGet]
@@ -562,47 +496,126 @@ namespace gaseous_server.Controllers
        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
        [HttpGet]
-        [Route("{GameId}/cover/image/{size}")]
-        [Route("{GameId}/cover/image/{size}/{imagename}")]
+        [Route("{GameId}/{ImageType}/{ImageId}/image/{size}")]
+        [Route("{GameId}/{ImageType}/{ImageId}/image/{size}/{imagename}")]
        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public async Task<ActionResult> GameCoverImage(long GameId, Communications.IGDBAPI_ImageSize size, string imagename = "")
+        public async Task<ActionResult> GameImage(long GameId, MetadataImageType imageType, long ImageId, Communications.IGDBAPI_ImageSize size, string imagename = "")
        {
            try
            {
                IGDB.Models.Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);

-                if (gameObject.Cover != null)
+                string? imageId = null;
+                string? imageTypePath = null;
+
+                switch (imageType)
                {
-                    if (gameObject.Cover.Id != null)
-                    {
-                        IGDB.Models.Cover cover = Classes.Metadata.Covers.GetCover(gameObject.Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), false);
-                        string basePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), "Covers");
-                        
-                        Communications comms = new Communications();
-                        Task<string> ImgFetch = comms.GetSpecificImageFromServer(basePath, cover.ImageId, size, new List<Communications.IGDBAPI_ImageSize>{ Communications.IGDBAPI_ImageSize.cover_big, Communications.IGDBAPI_ImageSize.original });
-
-                        string coverFilePath = ImgFetch.Result;
-
-                        if (System.IO.File.Exists(coverFilePath)) {
-                            string filename = cover.ImageId + ".jpg";
-                            string filepath = coverFilePath;
-                            byte[] filedata = System.IO.File.ReadAllBytes(filepath);
-                            string contentType = "image/jpg";
-
-                            var cd = new System.Net.Mime.ContentDisposition
+                    case MetadataImageType.cover:
+                        if (gameObject.Cover != null)
+                        {
+                            if (gameObject.Cover.Id != null)
                            {
-                                FileName = filename,
-                                Inline = true,
-                            };
+                                IGDB.Models.Cover cover = Classes.Metadata.Covers.GetCover(gameObject.Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), false);
+                                imageId = cover.ImageId;
+                                imageTypePath = "Covers";
+                            }
+                        }
+                        else
+                        {
+                            return NotFound();
+                        }
+                        break;

-                            Response.Headers.Add("Content-Disposition", cd.ToString());
-                            Response.Headers.Add("Cache-Control", "public, max-age=604800");
+                    case MetadataImageType.screenshots:
+                        if (gameObject.Screenshots != null)
+                        {
+                            if (gameObject.Screenshots.Ids.Contains(ImageId))
+                            {
+                                IGDB.Models.Screenshot imageObject = Screenshots.GetScreenshot(ImageId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), true);

-                            return File(filedata, contentType);
+                                imageId = imageObject.ImageId;
+                                imageTypePath = "Screenshots";
+                            }
+                        }
+                        else
+                        {
+                            return NotFound();
+                        }
+                        break;
+
+                    case MetadataImageType.artwork:
+                        if (gameObject.Artworks != null)
+                        {
+                            if (gameObject.Artworks.Ids.Contains(ImageId))
+                            {
+                                IGDB.Models.Artwork imageObject = Artworks.GetArtwork(ImageId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), true);
+
+                                imageId = imageObject.ImageId;
+                                imageTypePath = "Artwork";
+                            }
+                        }
+                        else
+                        {
+                            return NotFound();
+                        }
+                        break;
+
+                    default:
+                        return NotFound();
+                }
+
+                if (imageId == null)
+                {
+                    return NotFound();
+                }
+
+                string basePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), imageTypePath);
+                string imagePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), imageTypePath, size.ToString(), imageId + ".jpg");
+
+                if (!System.IO.File.Exists(imagePath))
+                {
+                    Communications comms = new Communications();
+                    Task<string> ImgFetch = comms.GetSpecificImageFromServer(Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), imageTypePath), imageId, size, new List<Communications.IGDBAPI_ImageSize> { Communications.IGDBAPI_ImageSize.cover_big, Communications.IGDBAPI_ImageSize.original });
+
+                    imagePath = ImgFetch.Result;
+                }
+
+                if (!System.IO.File.Exists(imagePath))
+                {
+                    Communications comms = new Communications();
+                    Task<string> ImgFetch = comms.GetSpecificImageFromServer(basePath, imageId, size, new List<Communications.IGDBAPI_ImageSize> { Communications.IGDBAPI_ImageSize.cover_big, Communications.IGDBAPI_ImageSize.original });
+
+                    imagePath = ImgFetch.Result;
+                }
+
+                if (System.IO.File.Exists(imagePath))
+                {
+                    string filename = imageId + ".jpg";
+                    string filepath = imagePath;
+                    string contentType = "image/jpg";
+
+                    var cd = new System.Net.Mime.ContentDisposition
+                    {
+                        FileName = filename,
+                        Inline = true,
+                    };
+
+                    Response.Headers.Add("Content-Disposition", cd.ToString());
+                    Response.Headers.Add("Cache-Control", "public, max-age=604800");
+
+                    byte[] filedata = null;
+                    using (FileStream fs = System.IO.File.OpenRead(filepath))
+                    {
+                        using (BinaryReader binaryReader = new BinaryReader(fs))
+                        {
+                            filedata = binaryReader.ReadBytes((int)fs.Length);
                        }
                    }
+
+                    return File(filedata, contentType);
                }
+
                return NotFound();
            }
            catch
@@ -611,6 +624,13 @@ namespace gaseous_server.Controllers
            }
        }

+        public enum MetadataImageType
+        {
+            cover,
+            screenshots,
+            artwork
+        }
+

        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
@@ -796,7 +816,8 @@ namespace gaseous_server.Controllers
                        companyData.Add("company", company);

                        return Ok(companyData);
-                    } else
+                    }
+                    else
                    {
                        return NotFound();
                    }
@@ -857,17 +878,146 @@ namespace gaseous_server.Controllers
            }
        }

+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Route("{GameId}/emulatorconfiguration/{PlatformId}")]
+        [Authorize]
+        [ProducesResponseType(typeof(UserEmulatorConfiguration), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public async Task<ActionResult> GetGameEmulator(long GameId, long PlatformId)
+        {
+            try
+            {
+                IGDB.Models.Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);
+
+                if (gameObject != null)
+                {
+                    IGDB.Models.Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
+
+                    if (platformObject != null)
+                    {
+                        var user = await _userManager.GetUserAsync(User);
+
+                        if (user != null)
+                        {
+                            PlatformMapping platformMapping = new PlatformMapping();
+                            UserEmulatorConfiguration platformMappingObject = platformMapping.GetUserEmulator(user.Id, GameId, PlatformId);
+
+                            if (platformMappingObject != null)
+                            {
+                                return Ok(platformMappingObject);
+                            }
+                        }
+                    }
+                }
+
+                return NotFound();
+            }
+            catch
+            {
+                return NotFound();
+            }
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPost]
+        [Route("{GameId}/emulatorconfiguration/{PlatformId}")]
+        [Authorize]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public async Task<ActionResult> SetGameEmulator(long GameId, long PlatformId, UserEmulatorConfiguration configuration)
+        {
+            try
+            {
+                IGDB.Models.Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);
+
+                if (gameObject != null)
+                {
+                    IGDB.Models.Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
+
+                    if (platformObject != null)
+                    {
+                        var user = await _userManager.GetUserAsync(User);
+
+                        if (user != null)
+                        {
+                            PlatformMapping platformMapping = new PlatformMapping();
+                            platformMapping.SetUserEmulator(user.Id, GameId, PlatformId, configuration);
+
+                            return Ok();
+                        }
+                    }
+                }
+
+                return NotFound();
+            }
+            catch
+            {
+                return NotFound();
+            }
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpDelete]
+        [Route("{GameId}/emulatorconfiguration/{PlatformId}")]
+        [Authorize]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public async Task<ActionResult> DeleteGameEmulator(long GameId, long PlatformId)
+        {
+            try
+            {
+                IGDB.Models.Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);
+
+                if (gameObject != null)
+                {
+                    IGDB.Models.Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
+
+                    if (platformObject != null)
+                    {
+                        var user = await _userManager.GetUserAsync(User);
+
+                        if (user != null)
+                        {
+                            PlatformMapping platformMapping = new PlatformMapping();
+                            platformMapping.DeleteUserEmulator(user.Id, GameId, PlatformId);
+
+                            return Ok();
+                        }
+                    }
+                }
+
+                return NotFound();
+            }
+            catch
+            {
+                return NotFound();
+            }
+        }
+
        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
        [HttpGet]
        [Route("{GameId}/platforms")]
-        [ProducesResponseType(typeof(List<KeyValuePair<long, string>>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(List<Games.AvailablePlatformItem>), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult> GamePlatforms(long GameId)
        {
            try
            {
-                return Ok(Games.GetAvailablePlatforms(GameId));
+                var user = await _userManager.GetUserAsync(User);
+
+                if (user != null)
+                {
+                    return Ok(Games.GetAvailablePlatforms(user.Id, GameId));
+                }
+                else
+                {
+                    return NotFound();
+                }
            }
            catch
            {
@@ -1025,6 +1175,67 @@ namespace gaseous_server.Controllers
            }
        }

+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPost]
+        [Route("{GameId}/roms/{RomId}/{PlatformId}/favourite")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public async Task<ActionResult> GameRomFavourite(long GameId, long RomId, long PlatformId, bool IsMediaGroup, bool favourite)
+        {
+            try
+            {
+                ApplicationUser? user = await _userManager.GetUserAsync(User);
+
+                Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);
+
+                if (IsMediaGroup == false)
+                {
+                    Classes.Roms.GameRomItem rom = Classes.Roms.GetRom(RomId);
+                    if (rom.GameId == GameId)
+                    {
+                        if (favourite == true)
+                        {
+                            Classes.Metadata.Games.GameSetFavouriteRom(user.Id, GameId, PlatformId, RomId, IsMediaGroup);
+                        }
+                        else
+                        {
+                            Classes.Metadata.Games.GameClearFavouriteRom(user.Id, GameId, PlatformId);
+                        }
+                        return Ok();
+                    }
+                    else
+                    {
+                        return NotFound();
+                    }
+                }
+                else
+                {
+                    Classes.RomMediaGroup.GameRomMediaGroupItem rom = Classes.RomMediaGroup.GetMediaGroup(RomId, user.Id);
+                    if (rom.GameId == GameId)
+                    {
+                        if (favourite == true)
+                        {
+                            Classes.Metadata.Games.GameSetFavouriteRom(user.Id, GameId, PlatformId, RomId, IsMediaGroup);
+                        }
+                        else
+                        {
+                            Classes.Metadata.Games.GameClearFavouriteRom(user.Id, GameId, PlatformId);
+                        }
+                        return Ok();
+                    }
+                    else
+                    {
+                        return NotFound();
+                    }
+                }
+            }
+            catch
+            {
+                return NotFound();
+            }
+        }
+
        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
        [HttpGet]
@@ -1137,11 +1348,10 @@ namespace gaseous_server.Controllers
        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
        [HttpGet]
-        [Authorize(Roles = "Admin,Gamer")]
        [Route("{GameId}/romgroup")]
        [ProducesResponseType(typeof(List<RomMediaGroup.GameRomMediaGroupItem>), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public async Task<ActionResult> GetGameRomGroupAsync(long GameId)
+        public async Task<ActionResult> GetGameRomGroupAsync(long GameId, long? PlatformId = null)
        {
            var user = await _userManager.GetUserAsync(User);

@@ -1151,7 +1361,7 @@ namespace gaseous_server.Controllers

                try
                {
-                    return Ok(RomMediaGroup.GetMediaGroupsFromGameId(GameId, user.Id));
+                    return Ok(RomMediaGroup.GetMediaGroupsFromGameId(GameId, user.Id, PlatformId));
                }
                catch (Exception ex)
                {
@@ -1388,7 +1598,8 @@ namespace gaseous_server.Controllers
            try
            {
                IGDB.Models.Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);
-                if (gameObject != null) { 
+                if (gameObject != null)
+                {
                    IGDB.Models.Screenshot screenshotObject = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), false);
                    if (screenshotObject != null)
                    {
@@ -1410,56 +1621,56 @@ namespace gaseous_server.Controllers
            }
        }

-        [MapToApiVersion("1.0")]
-        [MapToApiVersion("1.1")]
-        [HttpGet]
-        [Route("{GameId}/screenshots/{ScreenshotId}/image/{size}")]
-        [Route("{GameId}/screenshots/{ScreenshotId}/image/{size}/{ImageName}")]
-        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public async Task<ActionResult> GameScreenshotImage(long GameId, long ScreenshotId, Communications.IGDBAPI_ImageSize Size, string ImageName)
-        {
-            try
-            {
-                IGDB.Models.Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);
+        // [MapToApiVersion("1.0")]
+        // [MapToApiVersion("1.1")]
+        // [HttpGet]
+        // [Route("{GameId}/screenshots/{ScreenshotId}/image/{size}")]
+        // [Route("{GameId}/screenshots/{ScreenshotId}/image/{size}/{ImageName}")]
+        // [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
+        // [ProducesResponseType(StatusCodes.Status404NotFound)]
+        // public async Task<ActionResult> GameScreenshotImage(long GameId, long ScreenshotId, Communications.IGDBAPI_ImageSize Size, string ImageName)
+        // {
+        //     try
+        //     {
+        //         IGDB.Models.Game gameObject = Classes.Metadata.Games.GetGame(GameId, false, false, false);

-                IGDB.Models.Screenshot screenshotObject = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), true);
+        //         IGDB.Models.Screenshot screenshotObject = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), true);

-                string basePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), "Screenshots");
+        //         string basePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Game(gameObject), "Screenshots");

-                Communications comms = new Communications();
-                Task<string> ImgFetch = comms.GetSpecificImageFromServer(basePath, screenshotObject.ImageId, Size, new List<Communications.IGDBAPI_ImageSize>{ Communications.IGDBAPI_ImageSize.original });
+        //         Communications comms = new Communications();
+        //         Task<string> ImgFetch = comms.GetSpecificImageFromServer(basePath, screenshotObject.ImageId, Size, new List<Communications.IGDBAPI_ImageSize> { Communications.IGDBAPI_ImageSize.original });

-                string coverFilePath = ImgFetch.Result;
+        //         string coverFilePath = ImgFetch.Result;

-                if (System.IO.File.Exists(coverFilePath))
-                {
-                    string filename = screenshotObject.ImageId + ".jpg";
-                    string filepath = coverFilePath;
-                    byte[] filedata = System.IO.File.ReadAllBytes(filepath);
-                    string contentType = "image/jpg";
+        //         if (System.IO.File.Exists(coverFilePath))
+        //         {
+        //             string filename = screenshotObject.ImageId + ".jpg";
+        //             string filepath = coverFilePath;
+        //             byte[] filedata = System.IO.File.ReadAllBytes(filepath);
+        //             string contentType = "image/jpg";

-                    var cd = new System.Net.Mime.ContentDisposition
-                    {
-                        FileName = filename,
-                        Inline = true,
-                    };
+        //             var cd = new System.Net.Mime.ContentDisposition
+        //             {
+        //                 FileName = filename,
+        //                 Inline = true,
+        //             };

-                    Response.Headers.Add("Content-Disposition", cd.ToString());
-                    Response.Headers.Add("Cache-Control", "public, max-age=604800");
+        //             Response.Headers.Add("Content-Disposition", cd.ToString());
+        //             Response.Headers.Add("Cache-Control", "public, max-age=604800");

-                    return File(filedata, contentType);
-                }
-                else
-                {
-                    return NotFound();
-                }
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
+        //             return File(filedata, contentType);
+        //         }
+        //         else
+        //         {
+        //             return NotFound();
+        //         }
+        //     }
+        //     catch
+        //     {
+        //         return NotFound();
+        //     }
+        // }

        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
--- a/gaseous-server/Controllers/V1.0/LibraryController.cs
+++ b/gaseous-server/Controllers/V1.0/LibraryController.cs
@@ -86,5 +86,24 @@ namespace gaseous_server.Controllers
                return NotFound(exLNF.ToString());
            }
        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPost("{LibraryId}/Scan")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public ActionResult ScanLibrary(int LibraryId)
+        {
+            try
+            {
+                GameLibrary.ScanLibrary(LibraryId);
+                return Ok();
+            }
+            catch (GameLibrary.LibraryNotFound exLNF)
+            {
+                return NotFound(exLNF.ToString());
+            }
+        }
    }
 }
--- a/gaseous-server/Controllers/V1.0/PlatformMapsController.cs
+++ b/gaseous-server/Controllers/V1.0/PlatformMapsController.cs
@@ -149,35 +149,6 @@ namespace gaseous_server.Controllers
            return Ok(new { count = files.Count, size });
        }

-        // [MapToApiVersion("1.0")]
-        [MapToApiVersion("1.1")]
-        [HttpPost]
-        // [Route("{PlatformId}")]
-        // [ProducesResponseType(typeof(PlatformMapping.PlatformMapItem), StatusCodes.Status200OK)]
-        // [ProducesResponseType(StatusCodes.Status404NotFound)]
-        // [ProducesResponseType(StatusCodes.Status409Conflict)]
-        // public ActionResult NewPlatformMap(long PlatformId, PlatformMapping.PlatformMapItem Map)
-        // {
-        //     try
-        //     {
-        //         PlatformMapping.PlatformMapItem platformMapItem = PlatformMapping.GetPlatformMap(PlatformId);
-
-        //         if (platformMapItem != null)
-        //         {
-        //             return Conflict();
-        //         }
-        //         else
-        //         {
-        //             PlatformMapping.WritePlatformMap(Map, false, false);
-        //             return Ok(PlatformMapping.GetPlatformMap(PlatformId));
-        //         }
-        //     }
-        //     catch
-        //     {
-        //         return NotFound();
-        //     }
-        // }
-
        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
        [HttpPatch]
--- a/gaseous-server/Controllers/V1.0/PlatformsController.cs
+++ b/gaseous-server/Controllers/V1.0/PlatformsController.cs
@@ -114,22 +114,64 @@ namespace gaseous_server.Controllers
        [MapToApiVersion("1.0")]
        [MapToApiVersion("1.1")]
        [HttpGet]
-        [Route("{PlatformId}/platformlogo/image")]
+        [Route("{PlatformId}/platformlogo/{size}/logo.png")]
        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult PlatformLogoImage(long PlatformId)
+        public async Task<ActionResult> GameImage(long PlatformId, Communications.IGDBAPI_ImageSize size)
        {
            try
            {
                IGDB.Models.Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
-
-                string logoFilePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject), "Logo_Medium.png");
-                if (System.IO.File.Exists(logoFilePath))
+                IGDB.Models.PlatformLogo? logoObject = null;
+                try
                {
-                    string filename = "Logo.png";
-                    string filepath = logoFilePath;
-                    byte[] filedata = System.IO.File.ReadAllBytes(filepath);
-                    string contentType = "image/png";
+                    logoObject = PlatformLogos.GetPlatformLogo(platformObject.PlatformLogo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject));
+                }
+                catch
+                {
+                    // getting the logo failed, so we'll try a platform variant if available
+                    if (platformObject.Versions != null)
+                    {
+                        if (platformObject.Versions.Ids.Length > 0)
+                        {
+                            IGDB.Models.PlatformVersion platformVersion = Classes.Metadata.PlatformVersions.GetPlatformVersion(platformObject.Versions.Ids[0], platformObject);
+                            logoObject = PlatformLogos.GetPlatformLogo(platformVersion.PlatformLogo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject));
+                        }
+                        else
+                        {
+                            return NotFound();
+                        }
+                    }
+                    else
+                    {
+                        return NotFound();
+                    }
+                }
+
+                string basePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject));
+                string imagePath = Path.Combine(basePath, size.ToString(), logoObject.ImageId + ".jpg");
+
+                if (!System.IO.File.Exists(imagePath))
+                {
+                    Communications comms = new Communications();
+                    Task<string> ImgFetch = comms.GetSpecificImageFromServer(Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject)), logoObject.ImageId, size, new List<Communications.IGDBAPI_ImageSize> { Communications.IGDBAPI_ImageSize.cover_big, Communications.IGDBAPI_ImageSize.original });
+
+                    imagePath = ImgFetch.Result;
+                }
+
+                if (!System.IO.File.Exists(imagePath))
+                {
+                    Communications comms = new Communications();
+                    Task<string> ImgFetch = comms.GetSpecificImageFromServer(basePath, logoObject.ImageId, size, new List<Communications.IGDBAPI_ImageSize> { Communications.IGDBAPI_ImageSize.cover_big, Communications.IGDBAPI_ImageSize.original });
+
+                    imagePath = ImgFetch.Result;
+                }
+
+                if (System.IO.File.Exists(imagePath))
+                {
+                    string filename = logoObject.ImageId + ".jpg";
+                    string filepath = imagePath;
+                    string contentType = "image/jpg";

                    var cd = new System.Net.Mime.ContentDisposition
                    {
@@ -138,13 +180,21 @@ namespace gaseous_server.Controllers
                    };

                    Response.Headers.Add("Content-Disposition", cd.ToString());
+                    Response.Headers.Add("Cache-Control", "public, max-age=604800");
+
+                    byte[] filedata = null;
+                    using (FileStream fs = System.IO.File.OpenRead(filepath))
+                    {
+                        using (BinaryReader binaryReader = new BinaryReader(fs))
+                        {
+                            filedata = binaryReader.ReadBytes((int)fs.Length);
+                        }
+                    }

                    return File(filedata, contentType);
                }
-                else
-                {
-                    return NotFound();
-                }
+
+                return NotFound();
            }
            catch
            {
--- a/gaseous-server/Controllers/V1.0/RomsController.cs
+++ b/gaseous-server/Controllers/V1.0/RomsController.cs
@@ -31,63 +31,70 @@ namespace gaseous_server.Controllers
        [Authorize(Roles = "Admin,Gamer")]
        [ProducesResponseType(typeof(List<IFormFile>), StatusCodes.Status200OK)]
        [RequestSizeLimit(long.MaxValue)]
+        [Consumes("multipart/form-data")]
        [DisableRequestSizeLimit, RequestFormLimits(MultipartBodyLengthLimit = long.MaxValue, ValueLengthLimit = int.MaxValue)]
-        public async Task<IActionResult> UploadRom(List<IFormFile> files, long? OverridePlatformId = null)
+        public async Task<IActionResult> UploadRom(IFormFile file, long? OverridePlatformId = null)
        {
            Guid sessionid = Guid.NewGuid();

            string workPath = Path.Combine(Config.LibraryConfiguration.LibraryUploadDirectory, sessionid.ToString());

-            long size = files.Sum(f => f.Length);
-
-            List<Dictionary<string, object>> UploadedFiles = new List<Dictionary<string, object>>();
-
-            foreach (IFormFile formFile in files)
+            if (file.Length > 0)
            {
-                if (formFile.Length > 0)
+                Guid FileId = Guid.NewGuid();
+
+                string filePath = Path.Combine(workPath, Path.GetFileName(file.FileName));
+
+                if (!Directory.Exists(workPath))
                {
-                    Guid FileId = Guid.NewGuid();
-
-                    string filePath = Path.Combine(workPath, Path.GetFileName(formFile.FileName));
-
-                    if (!Directory.Exists(workPath))
-                    {
-                        Directory.CreateDirectory(workPath);
-                    }
-
-                    using (var stream = System.IO.File.Create(filePath))
-                    {
-                        await formFile.CopyToAsync(stream);
-
-                        Dictionary<string, object> UploadedFile = new Dictionary<string, object>();
-                        UploadedFile.Add("id", FileId.ToString());
-                        UploadedFile.Add("originalname", Path.GetFileName(formFile.FileName));
-                        UploadedFile.Add("fullpath", filePath);
-                        UploadedFiles.Add(UploadedFile);
-                    }
+                    Directory.CreateDirectory(workPath);
                }
-            }

-            // get override platform if specified
-            IGDB.Models.Platform? OverridePlatform = null;
-            if (OverridePlatformId != null)
-            {
-                OverridePlatform = Platforms.GetPlatform((long)OverridePlatformId);
-            }
+                Dictionary<string, object> UploadedFile = new Dictionary<string, object>();

-            // Process uploaded files
-            foreach (Dictionary<string, object> UploadedFile in UploadedFiles)
-            {
+                using (var stream = System.IO.File.Create(filePath))
+                {
+                    await file.CopyToAsync(stream);
+
+                    UploadedFile.Add("id", FileId.ToString());
+                    UploadedFile.Add("originalname", Path.GetFileName(file.FileName));
+                    UploadedFile.Add("fullpath", filePath);
+                }
+
+                // get override platform if specified
+                IGDB.Models.Platform? OverridePlatform = null;
+                if (OverridePlatformId != null)
+                {
+                    OverridePlatform = Platforms.GetPlatform((long)OverridePlatformId);
+                }
+
+                // Process uploaded file
                Classes.ImportGame uploadImport = new ImportGame();
-                uploadImport.ImportGameFile((string)UploadedFile["fullpath"], OverridePlatform);
+                Dictionary<string, object> RetVal = uploadImport.ImportGameFile((string)UploadedFile["fullpath"], OverridePlatform);
+                switch (RetVal["type"])
+                {
+                    case "rom":
+                        if (RetVal["status"] == "imported")
+                        {
+                            IGDB.Models.Game? game = (IGDB.Models.Game)RetVal["game"];
+                            if (game.Id == null)
+                            {
+                                RetVal["game"] = Games.GetGame(0, false, false, false);
+                            }
+                        }
+                        break;
+
+                }
+
+                if (Directory.Exists(workPath))
+                {
+                    Directory.Delete(workPath, true);
+                }
+
+                return Ok(RetVal);
            }

-            if (Directory.Exists(workPath))
-            {
-                Directory.Delete(workPath, true);
-            }
-
-            return Ok(new { count = files.Count, size });
+            return Ok();
        }
    }
 }
--- a/gaseous-server/Controllers/V1.0/SearchController.cs
+++ b/gaseous-server/Controllers/V1.0/SearchController.cs
@@ -73,7 +73,7 @@ namespace gaseous_server.Controllers
        private static async Task<List<GaseousGame>> _SearchForGame(long PlatformId, string SearchString)
        {
            string searchBody = "";
-            string searchFields = "fields cover,first_release_date,name,platforms,slug; ";
+            string searchFields = "fields *; ";
            searchBody += "search \"" + SearchString + "\";";
            searchBody += "where platforms = (" + PlatformId + ");";
            searchBody += "limit 100;";
@@ -91,7 +91,7 @@ namespace gaseous_server.Controllers
                foreach (Game game in results.ToList())
                {
                    Storage.CacheStatus cacheStatus = Storage.GetCacheStatus("Game", (long)game.Id);
-                    switch(cacheStatus)
+                    switch (cacheStatus)
                    {
                        case Storage.CacheStatus.NotPresent:
                            Storage.NewCacheValue(game, false);
--- a/gaseous-server/Controllers/V1.0/SignaturesController.cs
+++ b/gaseous-server/Controllers/V1.0/SignaturesController.cs
@@ -9,6 +9,7 @@ using gaseous_signature_parser.models.RomSignatureObject;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Asp.Versioning;
+using gaseous_server.Models;

 // For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860

@@ -54,11 +55,34 @@ namespace gaseous_server.Controllers
            {
                SignatureManagement signatureManagement = new SignatureManagement();
                return signatureManagement.GetByTosecName(TosecName);
-            } else
+            }
+            else
            {
                return null;
            }
        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public List<Signatures_Sources> GetSignatureSources()
+        {
+            SignatureManagement signatureManagement = new SignatureManagement();
+            return signatureManagement.GetSources();
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpDelete]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public IActionResult DeleteSignatureSource(int Id)
+        {
+            SignatureManagement signatureManagement = new SignatureManagement();
+            signatureManagement.DeleteSource(Id);
+
+            return Ok();
+        }
    }
 }

--- a/gaseous-server/Controllers/V1.0/SystemController.cs
+++ b/gaseous-server/Controllers/V1.0/SystemController.cs
@@ -38,7 +38,10 @@ namespace gaseous_server.Controllers
            List<SystemInfo.PathItem> Disks = new List<SystemInfo.PathItem>();
            foreach (GameLibrary.LibraryItem libraryItem in GameLibrary.GetLibraries)
            {
-                Disks.Add(GetDisk(libraryItem.Path));
+                SystemInfo.PathItem pathItem = GetDisk(libraryItem.Path);
+                pathItem.Name = libraryItem.Name;
+
+                Disks.Add(pathItem);
            }
            ReturnValue.Paths = Disks;

@@ -70,7 +73,8 @@ namespace gaseous_server.Controllers
        [HttpGet]
        [Route("Version")]
        [ProducesResponseType(StatusCodes.Status200OK)]
-        public Version GetSystemVersion() {
+        public Version GetSystemVersion()
+        {
            return Assembly.GetExecutingAssembly().GetName().Version;
        }

@@ -80,32 +84,36 @@ namespace gaseous_server.Controllers
        [Route("VersionFile")]
        [AllowAnonymous]
        [ProducesResponseType(StatusCodes.Status200OK)]
-        public FileContentResult GetSystemVersionAsFile() {
+        public FileContentResult GetSystemVersionAsFile()
+        {
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);

            // get age ratings dictionary
            Dictionary<int, string> ClassificationBoardsStrings = new Dictionary<int, string>();
-            foreach(IGDB.Models.AgeRatingCategory ageRatingCategory in Enum.GetValues(typeof(IGDB.Models.AgeRatingCategory)) )
+            foreach (IGDB.Models.AgeRatingCategory ageRatingCategory in Enum.GetValues(typeof(IGDB.Models.AgeRatingCategory)))
            {
                ClassificationBoardsStrings.Add((int)ageRatingCategory, ageRatingCategory.ToString());
            }

            Dictionary<int, string> AgeRatingsStrings = new Dictionary<int, string>();
-            foreach(IGDB.Models.AgeRatingTitle ageRatingTitle in Enum.GetValues(typeof(IGDB.Models.AgeRatingTitle)) )
+            foreach (IGDB.Models.AgeRatingTitle ageRatingTitle in Enum.GetValues(typeof(IGDB.Models.AgeRatingTitle)))
            {
                AgeRatingsStrings.Add((int)ageRatingTitle, ageRatingTitle.ToString());
            }

            string ver = "var AppVersion = \"" + Assembly.GetExecutingAssembly().GetName().Version.ToString() + "\";" + Environment.NewLine +
                "var DBSchemaVersion = \"" + db.GetDatabaseSchemaVersion() + "\";" + Environment.NewLine +
-                "var FirstRunStatus = " + Config.ReadSetting<string>("FirstRunStatus", "0") + ";" + Environment.NewLine +
-                "var AgeRatingBoardsStrings = " + JsonSerializer.Serialize(ClassificationBoardsStrings, new JsonSerializerOptions{
+                "var FirstRunStatus = \"" + Config.ReadSetting<string>("FirstRunStatus", "0") + "\";" + Environment.NewLine +
+                "var AgeRatingBoardsStrings = " + JsonSerializer.Serialize(ClassificationBoardsStrings, new JsonSerializerOptions
+                {
                    WriteIndented = true
                }) + ";" + Environment.NewLine +
-                "var AgeRatingStrings = " + JsonSerializer.Serialize(AgeRatingsStrings, new JsonSerializerOptions{
+                "var AgeRatingStrings = " + JsonSerializer.Serialize(AgeRatingsStrings, new JsonSerializerOptions
+                {
                    WriteIndented = true
                }) + ";" + Environment.NewLine +
-                "var AgeRatingGroups = " + JsonSerializer.Serialize(AgeGroups.AgeGroupingsFlat, new JsonSerializerOptions{
+                "var AgeRatingGroups = " + JsonSerializer.Serialize(AgeGroups.AgeGroupingsFlat, new JsonSerializerOptions
+                {
                    WriteIndented = true
                }) + ";" + Environment.NewLine +
                "var emulatorDebugMode = " + Config.ReadSetting<string>("emulatorDebugMode", false.ToString()).ToLower() + ";";
@@ -251,10 +259,18 @@ namespace gaseous_server.Controllers
        [ProducesResponseType(StatusCodes.Status200OK)]
        public ActionResult GetSystemSettings()
        {
-            SystemSettingsModel systemSettingsModel = new SystemSettingsModel{
+            SystemSettingsModel systemSettingsModel = new SystemSettingsModel
+            {
                AlwaysLogToDisk = Config.LoggingConfiguration.AlwaysLogToDisk,
                MinimumLogRetentionPeriod = Config.LoggingConfiguration.LogRetention,
-                EmulatorDebugMode = Boolean.Parse(Config.ReadSetting<string>("emulatorDebugMode", false.ToString()))
+                EmulatorDebugMode = Boolean.Parse(Config.ReadSetting<string>("emulatorDebugMode", false.ToString())),
+                SignatureSource = new SystemSettingsModel.SignatureSourceItem()
+                {
+                    Source = Config.MetadataConfiguration.SignatureSource,
+                    HasheousHost = Config.MetadataConfiguration.HasheousHost,
+                    HasheousSubmitFixes = (bool)Config.MetadataConfiguration.HasheousSubmitFixes,
+                    HasheousAPIKey = Config.MetadataConfiguration.HasheousAPIKey
+                }
            };

            return Ok(systemSettingsModel);
@@ -273,6 +289,10 @@ namespace gaseous_server.Controllers
                Config.LoggingConfiguration.AlwaysLogToDisk = model.AlwaysLogToDisk;
                Config.LoggingConfiguration.LogRetention = model.MinimumLogRetentionPeriod;
                Config.SetSetting<string>("emulatorDebugMode", model.EmulatorDebugMode.ToString());
+                Config.MetadataConfiguration.SignatureSource = model.SignatureSource.Source;
+                Config.MetadataConfiguration.HasheousHost = model.SignatureSource.HasheousHost;
+                Config.MetadataConfiguration.HasheousAPIKey = model.SignatureSource.HasheousAPIKey;
+                Config.MetadataConfiguration.HasheousSubmitFixes = model.SignatureSource.HasheousSubmitFixes;
                Config.UpdateConfig();
            }

@@ -281,7 +301,8 @@ namespace gaseous_server.Controllers

        private SystemInfo.PathItem GetDisk(string Path)
        {
-            SystemInfo.PathItem pathItem = new SystemInfo.PathItem {
+            SystemInfo.PathItem pathItem = new SystemInfo.PathItem
+            {
                LibraryPath = Path,
                SpaceUsed = Common.DirSize(new DirectoryInfo(Path)),
                SpaceAvailable = new DriveInfo(Path).AvailableFreeSpace,
@@ -293,11 +314,12 @@ namespace gaseous_server.Controllers

        public class SystemInfo
        {
-            public Version ApplicationVersion { 
+            public Version ApplicationVersion
+            {
                get
-                    {
-                        return Assembly.GetExecutingAssembly().GetName().Version;
-                    }
+                {
+                    return Assembly.GetExecutingAssembly().GetName().Version;
+                }
            }
            public List<PathItem>? Paths { get; set; }
            public long DatabaseSize { get; set; }
@@ -305,6 +327,7 @@ namespace gaseous_server.Controllers

            public class PathItem
            {
+                public string Name { get; set; }
                public string LibraryPath { get; set; }
                public long SpaceUsed { get; set; }
                public long SpaceAvailable { get; set; }
@@ -589,7 +612,8 @@ namespace gaseous_server.Controllers
        }
        private bool _UserManageable;
        public bool UserManageable => _UserManageable;
-        public int Interval {
+        public int Interval
+        {
            get
            {
                return int.Parse(Config.ReadSetting<string>("Interval_" + Task, DefaultInterval.ToString()));
@@ -710,5 +734,14 @@ namespace gaseous_server.Controllers
        public bool AlwaysLogToDisk { get; set; }
        public int MinimumLogRetentionPeriod { get; set; }
        public bool EmulatorDebugMode { get; set; }
+        public SignatureSourceItem SignatureSource { get; set; }
+
+        public class SignatureSourceItem
+        {
+            public HasheousClient.Models.MetadataModel.SignatureSources Source { get; set; }
+            public string HasheousHost { get; set; }
+            public string HasheousAPIKey { get; set; }
+            public bool HasheousSubmitFixes { get; set; }
+        }
    }
 }
--- a/gaseous-server/Controllers/V1.1/FileSystemController.cs
+++ b/gaseous-server/Controllers/V1.1/FileSystemController.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using gaseous_server.Classes;
+using gaseous_server.Classes.Metadata;
+using IGDB.Models;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.CodeAnalysis.Scripting;
+using static gaseous_server.Classes.Metadata.AgeRatings;
+using Asp.Versioning;
+
+namespace gaseous_server.Controllers.v1_1
+{
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [ApiVersion("1.1")]
+    [ApiController]
+    public class FileSystemController : ControllerBase
+    {
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Authorize(Roles = "Admin")]
+        [ProducesResponseType(typeof(FileContentResult), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public ActionResult GetFileSystem(string path, bool showFiles = false)
+        {
+            try
+            {
+                if (path.Contains(".."))
+                {
+                    return NotFound();
+                }
+
+                if (Directory.Exists(path))
+                {
+                    Dictionary<string, List<Dictionary<string, string>>> allFiles = new Dictionary<string, List<Dictionary<string, string>>>();
+                    List<Dictionary<string, string>> directories = new List<Dictionary<string, string>>();
+                    string[] dirs = Directory.GetDirectories(path);
+                    Array.Sort(dirs);
+                    foreach (string dir in dirs)
+                    {
+                        DirectoryInfo directoryInfo = new DirectoryInfo(dir);
+                        directories.Add(new Dictionary<string, string> { { "name", directoryInfo.Name }, { "path", directoryInfo.FullName } });
+                    }
+                    allFiles.Add("directories", directories);
+
+                    if (showFiles == true)
+                    {
+                        List<Dictionary<string, string>> files = new List<Dictionary<string, string>>();
+                        string[] filePaths = Directory.GetFiles(path);
+                        Array.Sort(filePaths);
+                        foreach (string file in filePaths)
+                        {
+                            FileInfo fileInfo = new FileInfo(file);
+                            files.Add(new Dictionary<string, string> { { "name", fileInfo.Name }, { "path", fileInfo.FullName } });
+                        }
+                        allFiles.Add("files", files);
+                    }
+
+                    return Ok(allFiles);
+                }
+                else
+                {
+                    return NotFound();
+
+                }
+            }
+            catch (Exception ex)
+            {
+                return NotFound();
+            }
+        }
+    }
+}
--- a/gaseous-server/Controllers/V1.1/GamesController.cs
+++ b/gaseous-server/Controllers/V1.1/GamesController.cs
@@ -26,7 +26,7 @@ namespace gaseous_server.Controllers.v1_1
    [ApiVersion("1.1")]
    [ApiController]
    [Authorize]
-    public class GamesController: ControllerBase
+    public class GamesController : ControllerBase
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;
@@ -106,7 +106,8 @@ namespace gaseous_server.Controllers.v1_1
            if (user != null)
            {
                string IncludeUnrated = "";
-                if (user.SecurityProfile.AgeRestrictionPolicy.IncludeUnrated == true) {
+                if (user.SecurityProfile.AgeRestrictionPolicy.IncludeUnrated == true)
+                {
                    IncludeUnrated = " OR view_Games.AgeGroupId IS NULL";
                }

@@ -446,7 +447,7 @@ namespace gaseous_server.Controllers.v1_1
            string orderByOrder = "ASC";
            if (model.Sorting != null)
            {
-                switch(model.Sorting.SortBy)
+                switch (model.Sorting.SortBy)
                {
                    case GameSearchModel.GameSortingItem.SortField.NameThe:
                        orderByField = "NameThe";
@@ -485,6 +486,7 @@ SELECT DISTINCT
    Game.`Name`,
    Game.NameThe,
    Game.Slug,
+    Game.Summary,
    Game.PlatformId,
    Game.TotalRating,
    Game.TotalRatingCount,
@@ -551,7 +553,7 @@ FROM
    Favourites ON Game.Id = Favourites.GameId AND Favourites.UserId = @userid " + whereClause + " " + havingClause + " " + orderByClause;
            List<Games.MinimalGameItem> RetVal = new List<Games.MinimalGameItem>();

-            DataTable dbResponse = db.ExecuteCMD(sql, whereParams);
+            DataTable dbResponse = db.ExecuteCMD(sql, whereParams, new Database.DatabaseMemoryCacheOptions(CacheEnabled: true, ExpirationSeconds: 60));

            // get count
            int RecordCount = dbResponse.Rows.Count;
@@ -568,7 +570,7 @@ FROM
                    }
                }

-                Game retGame = Storage.BuildCacheObject<Game>(new Game() , dbResponse.Rows[i]);
+                Game retGame = Storage.BuildCacheObject<Game>(new Game(), dbResponse.Rows[i]);
                Games.MinimalGameItem retMinGame = new Games.MinimalGameItem(retGame);
                retMinGame.Index = i;
                if (dbResponse.Rows[i]["RomSaveCount"] != DBNull.Value || dbResponse.Rows[i]["MediaGroupSaveCount"] != DBNull.Value)
@@ -593,29 +595,44 @@ FROM

            // build alpha list
            Dictionary<string, int> AlphaList = new Dictionary<string, int>();
-            int CurrentPage = 1;
-            int NextPageIndex = pageSize;
-            for (int i = 0; i < dbResponse.Rows.Count; i++)
+            if (orderByField == "NameThe" || orderByField == "Name")
            {
-                string firstChar = dbResponse.Rows[i]["NameThe"].ToString().Substring(0, 1).ToUpperInvariant();
-                if (!"ABCDEFGHIJKLMNOPQRSTUVWXYZ".Contains(firstChar))
+                int CurrentPage = 1;
+                int NextPageIndex = pageSize;
+
+                string alphaSearchField;
+                if (orderByField == "NameThe")
                {
-                    if (!AlphaList.ContainsKey("#"))
-                    {
-                        AlphaList.Add("#", 1);
-                    }
+                    alphaSearchField = "NameThe";
                }
                else
                {
-                    if (!AlphaList.ContainsKey(firstChar))
-                    {
-                        AlphaList.Add(firstChar, CurrentPage);
-                    }
+                    alphaSearchField = "Name";
+                }
+
+                for (int i = 0; i < dbResponse.Rows.Count; i++)
+                {
                    if (NextPageIndex == i + 1)
                    {
                        NextPageIndex += pageSize;
                        CurrentPage += 1;
                    }
+
+                    string firstChar = dbResponse.Rows[i][alphaSearchField].ToString().Substring(0, 1).ToUpperInvariant();
+                    if ("ABCDEFGHIJKLMNOPQRSTUVWXYZ".Contains(firstChar))
+                    {
+                        if (!AlphaList.ContainsKey(firstChar))
+                        {
+                            AlphaList.Add(firstChar, CurrentPage);
+                        }
+                    }
+                    else
+                    {
+                        if (!AlphaList.ContainsKey("#"))
+                        {
+                            AlphaList.Add("#", 1);
+                        }
+                    }
                }
            }

--- a/gaseous-server/Controllers/V1.1/StateManagerController.cs
+++ b/gaseous-server/Controllers/V1.1/StateManagerController.cs
@@ -6,6 +6,8 @@ using Authentication;
 using Microsoft.AspNetCore.Identity;
 using System.Data;
 using Asp.Versioning;
+using System.IO.Compression;
+using gaseous_server.Classes.Metadata;

 namespace gaseous_server.Controllers.v1_1
 {
@@ -13,7 +15,7 @@ namespace gaseous_server.Controllers.v1_1
    [ApiVersion("1.0")]
    [ApiVersion("1.1")]
    [ApiController]
-    public class StateManagerController: ControllerBase
+    public class StateManagerController : ControllerBase
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;
@@ -233,11 +235,11 @@ namespace gaseous_server.Controllers.v1_1
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [Route("{RomId}/{StateId}/State/")]
        [Route("{RomId}/{StateId}/State/savestate.state")]
-        public async Task<ActionResult> GetStateDataAsync(long RomId, long StateId, bool IsMediaGroup = false)
+        public async Task<ActionResult> GetStateDataAsync(long RomId, long StateId, bool IsMediaGroup = false, bool StateOnly = false)
        {
            var user = await _userManager.GetUserAsync(User);
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT Zipped, State FROM GameState WHERE Id = @id AND RomId = @romid AND IsMediaGroup = @ismediagroup AND UserId = @userid;";
+            string sql = "SELECT * FROM GameState WHERE Id = @id AND RomId = @romid AND IsMediaGroup = @ismediagroup AND UserId = @userid;";
            Dictionary<string, object> dbDict = new Dictionary<string, object>
            {
                { "id", StateId },
@@ -254,7 +256,27 @@ namespace gaseous_server.Controllers.v1_1
            }
            else
            {
-                string filename = "savestate.state";
+                // get rom data
+                string romName = "";
+                string romMd5 = "";
+                string romSha1 = "";
+                if (IsMediaGroup == false)
+                {
+                    Roms.GameRomItem romItem = Roms.GetRom(RomId);
+                    romName = romItem.Name;
+                    romMd5 = romItem.Md5;
+                    romSha1 = romItem.Sha1;
+                }
+                else
+                {
+                    RomMediaGroup.GameRomMediaGroupItem mediaGroupItem = RomMediaGroup.GetMediaGroup(RomId);
+                    IGDB.Models.Game game = Games.GetGame(mediaGroupItem.GameId, false, false, false);
+                    Classes.Common.hashObject hashObject = new Classes.Common.hashObject(Path.Combine(Config.LibraryConfiguration.LibraryMediaGroupDirectory, mediaGroupItem.Id.ToString() + ".zip"));
+                    romName = game.Name;
+                    romMd5 = hashObject.md5hash;
+                    romSha1 = hashObject.sha1hash;
+                }
+
                byte[] bytes;
                if ((bool)data.Rows[0]["Zipped"] == false)
                {
@@ -264,7 +286,85 @@ namespace gaseous_server.Controllers.v1_1
                {
                    bytes = Common.Decompress((byte[])data.Rows[0]["State"]);
                }
-                string contentType = "application/octet-stream";
+                string contentType = "";
+                string filename = ((DateTime)data.Rows[0]["StateDateTime"]).ToString("yyyy-MM-ddTHH-mm-ss") + "-" + Path.GetFileNameWithoutExtension(romName);
+
+
+                if (StateOnly == true)
+                {
+                    contentType = "application/octet-stream";
+                    filename = filename + ".state";
+                }
+                else
+                {
+                    contentType = "application/zip";
+                    filename = filename + ".zip";
+
+                    Dictionary<string, object> RomInfo = new Dictionary<string, object>
+                     {
+                         { "Name", romName },
+                         { "StateDateTime", data.Rows[0]["StateDateTime"] },
+                         { "StateName", data.Rows[0]["Name"] }
+                     };
+                    if ((int)data.Rows[0]["IsMediaGroup"] == 0)
+                    {
+                        RomInfo.Add("MD5", romMd5);
+                        RomInfo.Add("SHA1", romSha1);
+                        RomInfo.Add("Type", "ROM");
+                    }
+                    else
+                    {
+                        RomInfo.Add("Type", "Media Group");
+                        RomInfo.Add("MediaGroupId", (long)data.Rows[0]["RomId"]);
+                    }
+                    string RomInfoString = Newtonsoft.Json.JsonConvert.SerializeObject(RomInfo, Newtonsoft.Json.Formatting.Indented, new Newtonsoft.Json.JsonSerializerSettings { NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore });
+
+                    // compile zip file
+                    using (var compressedFileStream = new MemoryStream())
+                    {
+                        List<Dictionary<string, object>> Attachments = new List<Dictionary<string, object>>();
+                        Attachments.Add(new Dictionary<string, object>
+                         {
+                             { "Name", "savestate.state" },
+                             { "Body", bytes }
+                         });
+                        // check if value is dbnull
+                        if (data.Rows[0]["Screenshot"] != DBNull.Value)
+                        {
+                            Attachments.Add(new Dictionary<string, object>
+                             {
+                                 { "Name", "screenshot.jpg" },
+                                 { "Body", (byte[])data.Rows[0]["Screenshot"] }
+                             });
+                        }
+                        Attachments.Add(new Dictionary<string, object>
+                         {
+                             { "Name", "rominfo.json" },
+                             { "Body", System.Text.Encoding.UTF8.GetBytes(RomInfoString) }
+                         });
+
+                        //Create an archive and store the stream in memory.
+                        using (var zipArchive = new ZipArchive(compressedFileStream, ZipArchiveMode.Create, false))
+                        {
+                            foreach (var Attachment in Attachments)
+                            {
+                                //Create a zip entry for each attachment
+                                var zipEntry = zipArchive.CreateEntry(Attachment["Name"].ToString());
+
+                                //Get the stream of the attachment
+                                using (var originalFileStream = new MemoryStream((byte[])Attachment["Body"]))
+                                using (var zipEntryStream = zipEntry.Open())
+                                {
+                                    //Copy the attachment stream to the zip entry stream
+                                    originalFileStream.CopyTo(zipEntryStream);
+                                }
+                            }
+                        }
+
+                        //return new FileContentResult(compressedFileStream.ToArray(), "application/zip") { FileDownloadName = filename };
+                        bytes = compressedFileStream.ToArray();
+                    }
+                }

                var cd = new System.Net.Mime.ContentDisposition
                {
@@ -279,6 +379,156 @@ namespace gaseous_server.Controllers.v1_1
            }
        }

+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPost]
+        [Authorize]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [RequestSizeLimit(long.MaxValue)]
+        [Consumes("multipart/form-data")]
+        [DisableRequestSizeLimit, RequestFormLimits(MultipartBodyLengthLimit = long.MaxValue, ValueLengthLimit = int.MaxValue)]
+        [Route("Upload")]
+        public async Task<ActionResult> UploadStateDataAsync(IFormFile file, long RomId = 0, bool IsMediaGroup = false)
+        {
+            // get user
+            var user = await _userManager.GetUserAsync(User);
+
+            if (file.Length > 0)
+            {
+                MemoryStream fileContent = new MemoryStream();
+                file.CopyTo(fileContent);
+
+                // test if file is a zip file
+                try
+                {
+                    using (var zipArchive = new ZipArchive(fileContent, ZipArchiveMode.Read, false))
+                    {
+                        foreach (var entry in zipArchive.Entries)
+                        {
+                            if (entry.FullName == "rominfo.json")
+                            {
+                                using (var stream = entry.Open())
+                                using (var reader = new StreamReader(stream))
+                                {
+                                    string RomInfoString = reader.ReadToEnd();
+                                    Dictionary<string, object> RomInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(RomInfoString);
+
+                                    // get rom data
+                                    Roms.GameRomItem romItem;
+
+                                    try
+                                    {
+                                        romItem = Roms.GetRom((string)RomInfo["MD5"]);
+                                    }
+                                    catch (Roms.InvalidRomHash)
+                                    {
+                                        return NotFound();
+                                    }
+
+                                    // get state data
+                                    byte[] StateData = null;
+                                    byte[] ScreenshotData = null;
+                                    string StateName = RomInfo["StateName"].ToString();
+                                    DateTime StateDateTime = DateTime.Parse(RomInfo["StateDateTime"].ToString());
+                                    IsMediaGroup = RomInfo["Type"].ToString() == "Media Group" ? true : false;
+
+                                    if (zipArchive.GetEntry("savestate.state") != null)
+                                    {
+                                        using (var stateStream = zipArchive.GetEntry("savestate.state").Open())
+                                        using (var stateReader = new MemoryStream())
+                                        {
+                                            stateStream.CopyTo(stateReader);
+                                            StateData = stateReader.ToArray();
+                                        }
+                                    }
+                                    if (zipArchive.GetEntry("screenshot.jpg") != null)
+                                    {
+                                        using (var screenshotStream = zipArchive.GetEntry("screenshot.jpg").Open())
+                                        using (var screenshotReader = new MemoryStream())
+                                        {
+                                            screenshotStream.CopyTo(screenshotReader);
+                                            ScreenshotData = screenshotReader.ToArray();
+                                        }
+                                    }
+
+                                    // save state
+                                    Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                                    string sql = "INSERT INTO GameState (UserId, RomId, IsMediaGroup, StateDateTime, Name, Screenshot, State, Zipped) VALUES (@userid, @romid, @ismediagroup, @statedatetime, @name, @screenshot, @state, @zipped); SELECT LAST_INSERT_ID();";
+                                    Dictionary<string, object> dbDict = new Dictionary<string, object>
+                                     {
+                                         { "userid", user.Id },
+                                         { "romid", romItem.Id },
+                                         { "ismediagroup", IsMediaGroup },
+                                         { "statedatetime", StateDateTime },
+                                         { "name", StateName },
+                                         { "screenshot", ScreenshotData },
+                                         { "state", Common.Compress(StateData) },
+                                         { "zipped", true }
+                                     };
+                                    DataTable data = db.ExecuteCMD(sql, dbDict);
+
+                                    RomInfo.Add("RomId", romItem.Id);
+                                    RomInfo.Add("Management", "Managed");
+                                    return Ok(RomInfo);
+                                }
+                            }
+                        }
+                    }
+
+                    return BadRequest("File is not a valid Gaseous state file.");
+                }
+                catch
+                {
+                    // not a zip file
+                    if (RomId != 0)
+                    {
+                        // get rom data
+                        Roms.GameRomItem romItem;
+
+                        try
+                        {
+                            romItem = Roms.GetRom(RomId);
+                        }
+                        catch (Roms.InvalidRomHash)
+                        {
+                            return NotFound();
+                        }
+
+                        // save state
+                        Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                        string sql = "INSERT INTO GameState (UserId, RomId, IsMediaGroup, StateDateTime, Name, Screenshot, State, Zipped) VALUES (@userid, @romid, @ismediagroup, @statedatetime, @name, @screenshot, @state, @zipped); SELECT LAST_INSERT_ID();";
+                        Dictionary<string, object> dbDict = new Dictionary<string, object>
+                         {
+                             { "userid", user.Id },
+                             { "romid", RomId },
+                             { "ismediagroup", IsMediaGroup },
+                             { "statedatetime", DateTime.UtcNow },
+                             { "name", "" },
+                             { "screenshot", null },
+                             { "state", Common.Compress(fileContent.ToArray()) },
+                             { "zipped", true }
+                         };
+                        DataTable data = db.ExecuteCMD(sql, dbDict);
+
+                        return Ok(new Dictionary<string, object>
+                         {
+                             { "RomId", RomId },
+                             { "Management", "Unmanaged" }
+                         });
+                    }
+                    else
+                    {
+                        return BadRequest("No rom id provided.");
+                    }
+                }
+            }
+            else
+            {
+                return BadRequest("File is empty.");
+            }
+        }
+
        private Models.GameStateItem BuildGameStateItem(DataRow dr)
        {
            bool HasScreenshot = true;
--- a/gaseous-server/Controllers/V1.1/StatisticsController.cs
+++ b/gaseous-server/Controllers/V1.1/StatisticsController.cs
@@ -12,7 +12,7 @@ namespace gaseous_server.Controllers.v1_1
    [ApiVersion("1.0")]
    [ApiVersion("1.1")]
    [ApiController]
-    public class StatisticsController: ControllerBase
+    public class StatisticsController : ControllerBase
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;
@@ -32,15 +32,15 @@ namespace gaseous_server.Controllers.v1_1
        [Authorize]
        [ProducesResponseType(typeof(Models.StatisticsModel), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        [Route("Games/{GameId}/")]
-        public async Task<ActionResult> NewRecordStatistics(long GameId)
+        [Route("Games/{GameId}/{PlatformId}/{RomId}")]
+        public async Task<ActionResult> NewRecordStatistics(long GameId, long PlatformId, long RomId, bool IsMediaGroup)
        {
            var user = await _userManager.GetUserAsync(User);

            if (user != null)
            {
                Statistics statistics = new Statistics();
-                return Ok(statistics.RecordSession(Guid.Empty, GameId, user.Id));
+                return Ok(statistics.RecordSession(Guid.Empty, GameId, PlatformId, RomId, IsMediaGroup, user.Id));
            }
            else
            {
@@ -54,15 +54,15 @@ namespace gaseous_server.Controllers.v1_1
        [Authorize]
        [ProducesResponseType(typeof(Models.StatisticsModel), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        [Route("Games/{GameId}/{SessionId}")]
-        public async Task<ActionResult> SubsequentRecordStatistics(long GameId, Guid SessionId)
+        [Route("Games/{GameId}/{PlatformId}/{RomId}/{SessionId}")]
+        public async Task<ActionResult> SubsequentRecordStatistics(long GameId, long PlatformId, long RomId, Guid SessionId, bool IsMediaGroup)
        {
            var user = await _userManager.GetUserAsync(User);

            if (user != null)
            {
                Statistics statistics = new Statistics();
-                return Ok(statistics.RecordSession(SessionId, GameId, user.Id));
+                return Ok(statistics.RecordSession(SessionId, GameId, PlatformId, RomId, IsMediaGroup, user.Id));
            }
            else
            {
--- a/gaseous-server/Controllers/V1.1/UserProfileController.cs
+++ b/gaseous-server/Controllers/V1.1/UserProfileController.cs
@@ -0,0 +1,137 @@
+using Asp.Versioning;
+using Authentication;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+
+namespace gaseous_server.Controllers
+{
+    [ApiController]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [ApiVersion("1.0")]
+    [ApiVersion("1.1")]
+    [Authorize]
+    public class UserProfileController : ControllerBase
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+
+        public UserProfileController(
+            UserManager<ApplicationUser> userManager,
+            SignInManager<ApplicationUser> signInManager
+        )
+        {
+            _userManager = userManager;
+            _signInManager = signInManager;
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Route("{UserId}")]
+        [ProducesResponseType(typeof(Models.UserProfile), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ResponseCache(CacheProfileName = "5Minute")]
+        public ActionResult GetUserProfile(string UserId)
+        {
+            Classes.UserProfile profile = new Classes.UserProfile();
+            Models.UserProfile RetVal = profile.GetUserProfile(UserId);
+            return Ok(RetVal);
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPut]
+        [Route("{UserId}")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public async Task<ActionResult> UpdateUserProfileAsync(string UserId, Models.UserProfile profile)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user.ProfileId.ToString() != UserId)
+            {
+                return Unauthorized();
+            }
+
+            Classes.UserProfile userProfile = new Classes.UserProfile();
+            userProfile.UpdateUserProfile(user.Id, profile);
+            return Ok();
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPut]
+        [ProducesResponseType(typeof(List<IFormFile>), StatusCodes.Status200OK)]
+        [RequestSizeLimit(long.MaxValue)]
+        [Consumes("multipart/form-data")]
+        [DisableRequestSizeLimit, RequestFormLimits(MultipartBodyLengthLimit = long.MaxValue, ValueLengthLimit = int.MaxValue)]
+        [Route("{UserId}/{ProfileImageType}")]
+        public async Task<ActionResult> UpdateAvatarAsync(string UserId, Classes.UserProfile.ImageType ProfileImageType, IFormFile file)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user.ProfileId.ToString() != UserId)
+            {
+                return Unauthorized();
+            }
+
+            if (file.Length > 0)
+            {
+                using (var ms = new MemoryStream())
+                {
+                    file.CopyTo(ms);
+                    byte[] fileBytes = ms.ToArray();
+
+                    Classes.UserProfile userProfile = new Classes.UserProfile();
+                    userProfile.UpdateImage(ProfileImageType, UserId, user.Id, file.FileName, fileBytes);
+                }
+            }
+
+            return Ok();
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Route("{UserId}/{ProfileImageType}")]
+        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ResponseCache(CacheProfileName = "5Minute")]
+        public async Task<ActionResult> GetAvatarAsync(string UserId, Classes.UserProfile.ImageType ProfileImageType)
+        {
+            Classes.UserProfile userProfile = new Classes.UserProfile();
+
+            Models.ImageItem image = userProfile.GetImage(ProfileImageType, UserId);
+
+            if (image == null)
+            {
+                return NotFound();
+            }
+            else
+            {
+                return File(image.content, image.mimeType, UserId + image.extension);
+            }
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpDelete]
+        [Route("{UserId}/{ProfileImageType}")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        public async Task<ActionResult> DeleteAvatarAsync(string UserId, Classes.UserProfile.ImageType ProfileImageType)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user.ProfileId.ToString() != UserId)
+            {
+                return Unauthorized();
+            }
+
+            Classes.UserProfile userProfile = new Classes.UserProfile();
+            userProfile.DeleteImage(ProfileImageType, user.Id);
+
+            return Ok();
+        }
+    }
+}
--- a/gaseous-server/Models/GaseousGame.cs
+++ b/gaseous-server/Models/GaseousGame.cs
@@ -16,7 +16,7 @@ namespace gaseous_server.Models
        {
            var targetType = this.GetType();
            var sourceType = game.GetType();
-            foreach(var prop in targetType.GetProperties(BindingFlags.Instance | BindingFlags.Public| BindingFlags.SetProperty))
+            foreach (var prop in targetType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty))
            {
                // check whether source object has the the property
                var sp = sourceType.GetProperty(prop.Name);
@@ -39,9 +39,11 @@ namespace gaseous_server.Models
                {
                    if (this.Cover.Id != null)
                    {
-                        IGDB.Models.Cover cover = Covers.GetCover(Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(this), false);
-
-                        return cover;
+                        // IGDB.Models.Cover cover = Covers.GetCover(Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(this), false);
+                        IGDB.Models.Cover cover = new IGDB.Models.Cover()
+                        {
+                            Id = this.Cover.Id
+                        };
                    }
                }

--- a/gaseous-server/Models/ImageItem.cs
+++ b/gaseous-server/Models/ImageItem.cs
@@ -0,0 +1,9 @@
+namespace gaseous_server.Models
+{
+    public class ImageItem
+    {
+        public byte[] content { get; set; }
+        public string mimeType { get; set; }
+        public string extension { get; set; }
+    }
+}
--- a/gaseous-server/Models/PlatformMapping.cs
+++ b/gaseous-server/Models/PlatformMapping.cs
@@ -13,10 +13,8 @@ using Newtonsoft.Json;

 namespace gaseous_server.Models
 {
-	public class PlatformMapping
-	{
-        private static Dictionary<string, PlatformMapItem> PlatformMapCache = new Dictionary<string, PlatformMapItem>();
-
+    public class PlatformMapping
+    {
        /// <summary>
        /// Updates the platform map from the embedded platform map resource
        /// </summary>
@@ -27,7 +25,8 @@ namespace gaseous_server.Models
            {
                string rawJson = reader.ReadToEnd();
                List<PlatformMapItem> platforms = new List<PlatformMapItem>();
-                Newtonsoft.Json.JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings{
+                Newtonsoft.Json.JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings
+                {
                    MaxDepth = 64
                };
                platforms = Newtonsoft.Json.JsonConvert.DeserializeObject<List<PlatformMapItem>>(rawJson, jsonSerializerSettings);
@@ -73,8 +72,8 @@ namespace gaseous_server.Models

            foreach (PlatformMapItem mapItem in platforms)
            {
-                // get the IGDB platform data
-                Platform platform = Platforms.GetPlatform(mapItem.IGDBId);
+                // insert dummy platform data - it'll be cleaned up on the first metadata refresh
+                Platform platform = CreateDummyPlatform(mapItem);

                try
                {
@@ -93,73 +92,82 @@ namespace gaseous_server.Models
            }
        }

+        private static IGDB.Models.Platform CreateDummyPlatform(PlatformMapItem mapItem)
+        {
+            IGDB.Models.Platform platform = new IGDB.Models.Platform
+            {
+                Id = mapItem.IGDBId,
+                Name = mapItem.IGDBName,
+                Slug = mapItem.IGDBSlug,
+                AlternativeName = mapItem.AlternateNames.FirstOrDefault()
+            };
+
+            if (Storage.GetCacheStatus("Platform", mapItem.IGDBId) == Storage.CacheStatus.NotPresent)
+            {
+                Storage.NewCacheValue(platform);
+            }
+
+            return platform;
+        }
+
        public static List<PlatformMapItem> PlatformMap
        {
            get
            {
+                // if (Database.DatabaseMemoryCache.GetCacheObject("PlatformMap") != null)
+                // {
+                //     return (List<PlatformMapItem>)Database.DatabaseMemoryCache.GetCacheObject("PlatformMap");
+                // }
                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
                string sql = "SELECT * FROM PlatformMap";
-                DataTable data = db.ExecuteCMD(sql);
+                DataTable data = db.ExecuteCMD(sql); //, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromSeconds(5).Ticks));

                List<PlatformMapItem> platformMaps = new List<PlatformMapItem>();
                foreach (DataRow row in data.Rows)
                {
                    long mapId = (long)row["Id"];
-                    if (PlatformMapCache.ContainsKey(mapId.ToString()))
+
+                    PlatformMapItem mapItem = BuildPlatformMapItem(row);
+                    if (mapItem != null)
                    {
-                        PlatformMapItem mapItem = PlatformMapCache[mapId.ToString()];
-                        if (mapItem != null)
-                        {
-                            platformMaps.Add(mapItem);
-                        }
-                    }
-                    else
-                    {
-                        PlatformMapItem mapItem = BuildPlatformMapItem(row);
-                        if (mapItem != null)
-                        {
-                            platformMaps.Add(mapItem);
-                        }
+                        platformMaps.Add(mapItem);
                    }
                }

                platformMaps.Sort((x, y) => x.IGDBName.CompareTo(y.IGDBName));

+                //Database.DatabaseMemoryCache.SetCacheObject("PlatformMap", platformMaps, 600);
+
                return platformMaps;
            }
        }

        public static PlatformMapItem GetPlatformMap(long Id)
        {
-            if (PlatformMapCache.ContainsKey(Id.ToString()))
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM PlatformMap WHERE Id = @Id";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("Id", Id);
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            if (data.Rows.Count > 0)
            {
-                return PlatformMapCache[Id.ToString()];
+                PlatformMapItem platformMap = BuildPlatformMapItem(data.Rows[0]);
+
+                return platformMap;
            }
            else
            {
-                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-                string sql = "SELECT * FROM PlatformMap WHERE Id = @Id";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                dbDict.Add("Id", Id);
-                DataTable data = db.ExecuteCMD(sql, dbDict);
-
-                if (data.Rows.Count > 0)
-                {
-                    PlatformMapItem platformMap = BuildPlatformMapItem(data.Rows[0]);
-
-                    return platformMap;
-                }
-                else
-                {
-                    Exception exception = new Exception("Platform Map Id " + Id + " does not exist.");
-                    Logging.Log(Logging.LogType.Critical, "Platform Map", "Platform Map Id " + Id + " does not exist.", exception);
-                    throw exception;
-                }
+                Exception exception = new Exception("Platform Map Id " + Id + " does not exist.");
+                Logging.Log(Logging.LogType.Critical, "Platform Map", "Platform Map Id " + Id + " does not exist.", exception);
+                throw exception;
            }
        }

        public static void WritePlatformMap(PlatformMapItem item, bool Update, bool AllowAvailableEmulatorOverwrite)
        {
+            CreateDummyPlatform(item);
+
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
            string sql = "";
            Dictionary<string, object> dbDict = new Dictionary<string, object>();
@@ -238,23 +246,32 @@ namespace gaseous_server.Models
            {
                foreach (PlatformMapItem.EmulatorBiosItem biosItem in item.Bios)
                {
-                    sql = "INSERT INTO PlatformMap_Bios (Id, Filename, Description, Hash) VALUES (@Id, @Filename, @Description, @Hash);";
+                    bool isEnabled = false;
+                    if (item.EnabledBIOSHashes == null)
+                    {
+                        item.EnabledBIOSHashes = new List<string>();
+                    }
+                    if (item.EnabledBIOSHashes.Contains(biosItem.hash))
+                    {
+                        isEnabled = true;
+                    }
+
+                    sql = "INSERT INTO PlatformMap_Bios (Id, Filename, Description, Hash, Enabled) VALUES (@Id, @Filename, @Description, @Hash, @Enabled);";
                    dbDict.Clear();
                    dbDict.Add("Id", item.IGDBId);
                    dbDict.Add("Filename", biosItem.filename);
                    dbDict.Add("Description", biosItem.description);
                    dbDict.Add("Hash", biosItem.hash);
+                    dbDict.Add("Enabled", isEnabled);
                    db.ExecuteCMD(sql, dbDict);
                }
            }

-            if (PlatformMapCache.ContainsKey(item.IGDBId.ToString()))
-            {
-                PlatformMapCache.Remove(item.IGDBId.ToString());
-            }
+            // clear cache
+            Database.DatabaseMemoryCache.RemoveCacheObject("PlatformMap");
        }

-        public static void WriteAvailableEmulators (PlatformMapItem item)
+        public static void WriteAvailableEmulators(PlatformMapItem item)
        {
            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
            string sql = "";
@@ -286,7 +303,16 @@ namespace gaseous_server.Models
            string sql = "";

            // get platform data
-            IGDB.Models.Platform? platform = Platforms.GetPlatform(IGDBId);
+            // IGDB.Models.Platform? platform = Platforms.GetPlatform(IGDBId, false);
+            IGDB.Models.Platform? platform = null;
+            if (Storage.GetCacheStatus("Platform", IGDBId) == Storage.CacheStatus.NotPresent)
+            {
+                //platform = Platforms.GetPlatform(IGDBId, false);
+            }
+            else
+            {
+                platform = (IGDB.Models.Platform)Storage.GetCacheValue<IGDB.Models.Platform>(new Platform(), "id", IGDBId);
+            }

            if (platform != null)
            {
@@ -352,6 +378,7 @@ namespace gaseous_server.Models
                DataTable biosTable = db.ExecuteCMD(sql, dbDict);

                List<PlatformMapItem.EmulatorBiosItem> bioss = new List<PlatformMapItem.EmulatorBiosItem>();
+                List<string> enabledBios = new List<string>();
                foreach (DataRow biosRow in biosTable.Rows)
                {
                    PlatformMapItem.EmulatorBiosItem bios = new PlatformMapItem.EmulatorBiosItem
@@ -361,6 +388,11 @@ namespace gaseous_server.Models
                        hash = ((string)Common.ReturnValueIfNull(biosRow["Hash"], "")).ToLower()
                    };
                    bioss.Add(bios);
+
+                    if ((bool)Common.ReturnValueIfNull(biosRow["Enabled"], true) == true)
+                    {
+                        enabledBios.Add(bios.hash);
+                    }
                }

                // build item
@@ -369,26 +401,20 @@ namespace gaseous_server.Models
                mapItem.IGDBName = platform.Name;
                mapItem.IGDBSlug = platform.Slug;
                mapItem.AlternateNames = alternateNames;
-                mapItem.Extensions = new PlatformMapItem.FileExtensions{
+                mapItem.Extensions = new PlatformMapItem.FileExtensions
+                {
                    SupportedFileExtensions = knownExtensions,
                    UniqueFileExtensions = uniqueExtensions
                };
                mapItem.RetroPieDirectoryName = (string)Common.ReturnValueIfNull(row["RetroPieDirectoryName"], "");
-                mapItem.WebEmulator = new PlatformMapItem.WebEmulatorItem{
+                mapItem.WebEmulator = new PlatformMapItem.WebEmulatorItem
+                {
                    Type = (string)Common.ReturnValueIfNull(row["WebEmulator_Type"], ""),
                    Core = (string)Common.ReturnValueIfNull(row["WebEmulator_Core"], ""),
                    AvailableWebEmulators = Newtonsoft.Json.JsonConvert.DeserializeObject<List<PlatformMapItem.WebEmulatorItem.AvailableWebEmulatorItem>>((string)Common.ReturnValueIfNull(row["AvailableWebEmulators"], "[]"))
                };
                mapItem.Bios = bioss;
-                
-                if (PlatformMapCache.ContainsKey(IGDBId.ToString()))
-                {
-                    PlatformMapCache[IGDBId.ToString()] = mapItem;
-                }
-                else
-                {
-                    PlatformMapCache.Add(IGDBId.ToString(), mapItem);
-                }
+                mapItem.EnabledBIOSHashes = enabledBios;

                return mapItem;
            }
@@ -455,6 +481,74 @@ namespace gaseous_server.Models
            }
        }

+        public PlatformMapItem GetUserPlatformMap(string UserId, long PlatformId, long GameId)
+        {
+            // get the system enabled bios hashes
+            Models.PlatformMapping.PlatformMapItem platformMapItem = PlatformMapping.GetPlatformMap(PlatformId);
+
+            // get the user enabled bios hashes
+            PlatformMapping.UserEmulatorConfiguration userEmulatorConfiguration = GetUserEmulator(UserId, GameId, PlatformId);
+            if (userEmulatorConfiguration != null)
+            {
+                platformMapItem.WebEmulator.Type = userEmulatorConfiguration.EmulatorType;
+                platformMapItem.WebEmulator.Core = userEmulatorConfiguration.Core;
+                platformMapItem.EnabledBIOSHashes = userEmulatorConfiguration.EnableBIOSFiles;
+            }
+
+            return platformMapItem;
+        }
+
+        public UserEmulatorConfiguration GetUserEmulator(string UserId, long GameId, long PlatformId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT Mapping FROM User_PlatformMap WHERE id = @UserId AND GameId = @GameId AND PlatformId = @PlatformId;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "UserId", UserId },
+                { "GameId", GameId },
+                { "PlatformId", PlatformId }
+            };
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            if (data.Rows.Count > 0)
+            {
+                UserEmulatorConfiguration emulator = Newtonsoft.Json.JsonConvert.DeserializeObject<UserEmulatorConfiguration>((string)data.Rows[0]["Mapping"]);
+
+                return emulator;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public void SetUserEmulator(string UserId, long GameId, long PlatformId, UserEmulatorConfiguration Mapping)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "INSERT INTO User_PlatformMap (id, GameId, PlatformId, Mapping) VALUES (@UserId, @GameId, @PlatformId, @Mapping) ON DUPLICATE KEY UPDATE Mapping = @Mapping;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "UserId", UserId },
+                { "GameId", GameId },
+                { "PlatformId", PlatformId },
+                { "Mapping", Newtonsoft.Json.JsonConvert.SerializeObject(Mapping) }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public void DeleteUserEmulator(string UserId, long GameId, long PlatformId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM User_PlatformMap WHERE id = @UserId AND GameId = @GameId AND PlatformId = @PlatformId;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "UserId", UserId },
+                { "GameId", GameId },
+                { "PlatformId", PlatformId }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
        public class PlatformMapItem
        {
            public long IGDBId { get; set; }
@@ -502,7 +596,16 @@ namespace gaseous_server.Models
                public string description { get; set; }
                public string filename { get; set; }
            }
+
+            public List<string> EnabledBIOSHashes { get; set; }
        }
-	}
+
+        public class UserEmulatorConfiguration
+        {
+            public string EmulatorType { get; set; }
+            public string Core { get; set; }
+            public List<string> EnableBIOSFiles { get; set; } = new List<string>();
+        }
+    }
 }

--- a/gaseous-server/Models/Signatures_Games.cs
+++ b/gaseous-server/Models/Signatures_Games.cs
@@ -4,12 +4,36 @@ using gaseous_signature_parser.models.RomSignatureObject;

 namespace gaseous_server.Models
 {
-	public class Signatures_Games : HasheousClient.Models.LookupResponseModel
+	public class Signatures_Games : HasheousClient.Models.SignatureModel
 	{
 		public Signatures_Games()
 		{
 		}

+        [JsonIgnore]
+        public int Score
+        {
+            get
+            {
+                int _score = 0;
+
+                if (Game != null)
+                {
+                    _score = _score + Game.Score;
+                }
+
+                if (Rom != null)
+                {
+                    _score = _score + Rom.Score;
+                }
+
+                return _score;
+            }
+        }
+
+        public GameItem Game = new GameItem();
+        public RomItem Rom = new RomItem();
+
        public SignatureFlags Flags = new SignatureFlags();

        public class SignatureFlags
@@ -18,6 +42,213 @@ namespace gaseous_server.Models
            public string IGDBPlatformName { get; set; }
            public long IGDBGameId { get; set; }
        }
+
+        public class GameItem : HasheousClient.Models.SignatureModel.GameItem
+        {
+            public GameItem()
+            {
+
+            }
+
+            [JsonIgnore]
+            public int Score
+            {
+                get
+                {
+                    // calculate a score based on the availablility of data
+                    int _score = 0;
+                    var properties = this.GetType().GetProperties();
+                    foreach (var prop in properties)
+                    {
+                        if (prop.GetGetMethod() != null)
+                        {
+                            switch (prop.Name.ToLower())
+                            {
+                                case "id":
+                                case "score":
+                                    break;
+                                case "name":
+                                case "year":
+                                case "publisher":
+                                case "system":
+                                    if (prop.PropertyType == typeof(string))
+                                    {
+                                        if (prop.GetValue(this) != null)
+                                        {
+                                            string propVal = prop.GetValue(this).ToString();
+                                            if (propVal.Length > 0)
+                                            {
+                                                _score = _score + 10;
+                                            }
+                                        }
+                                    }
+                                    break;
+                                default:
+                                    if (prop.PropertyType == typeof(string))
+                                    {
+                                        if (prop.GetValue(this) != null)
+                                        {
+                                            string propVal = prop.GetValue(this).ToString();
+                                            if (propVal.Length > 0)
+                                            {
+                                                _score = _score + 1;
+                                            }
+                                        }
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+
+                    return _score;
+                }
+            }
+        }
+
+        public class RomItem : HasheousClient.Models.SignatureModel.RomItem
+        {
+            [JsonIgnore]
+            public int Score
+            {
+                get
+                {
+                    // calculate a score based on the availablility of data
+                    int _score = 0;
+                    var properties = this.GetType().GetProperties();
+                    foreach (var prop in properties)
+                    {
+                        if (prop.GetGetMethod() != null)
+                        {
+                            switch (prop.Name.ToLower())
+                            {
+                                case "name":
+                                case "size":
+                                case "crc":
+                                case "developmentstatus":
+                                case "flags":
+                                case "attributes":
+                                case "romtypemedia":
+                                case "medialabel":
+                                    if (prop.PropertyType == typeof(string) || prop.PropertyType == typeof(Int64) || prop.PropertyType == typeof(List<string>))
+                                    {
+                                        if (prop.GetValue(this) != null)
+                                        {
+                                            string propVal = prop.GetValue(this).ToString();
+                                            if (propVal.Length > 0)
+                                            {
+                                                _score = _score + 10;
+                                            }
+                                        }
+                                    }
+                                    break;
+                                default:
+                                    if (prop.PropertyType == typeof(string))
+                                    {
+                                        if (prop.GetValue(this) != null)
+                                        {
+                                            string propVal = prop.GetValue(this).ToString();
+                                            if (propVal.Length > 0)
+                                            {
+                                                _score = _score + 1;
+                                            }
+                                        }
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+
+                    return _score;
+                }
+            }
+
+            public class MediaType
+            {
+                public MediaType(SignatureSourceType Source, string MediaTypeString)
+                {
+                    switch (Source)
+                    {
+                        case RomItem.SignatureSourceType.TOSEC:
+                            string[] typeString = MediaTypeString.Split(" ");
+
+                            string inType = "";
+                            foreach (string typeStringVal in typeString)
+                            {
+                                if (inType == "")
+                                {
+                                    switch (typeStringVal.ToLower())
+                                    {
+                                        case "disk":
+                                            Media = RomItem.RomTypes.Disk;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "disc":
+                                            Media = RomItem.RomTypes.Disc;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "file":
+                                            Media = RomItem.RomTypes.File;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "part":
+                                            Media = RomItem.RomTypes.Part;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "tape":
+                                            Media = RomItem.RomTypes.Tape;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "of":
+                                            inType = typeStringVal;
+                                            break;
+                                        case "side":
+                                            inType = typeStringVal;
+                                            break;
+                                    }
+                                }
+                                else {
+                                    switch (inType.ToLower())
+                                    {
+                                        case "disk":
+                                        case "disc":
+                                        case "file":
+                                        case "part":
+                                        case "tape":
+                                            Number = int.Parse(typeStringVal);
+                                            break;
+                                        case "of":
+                                            Count = int.Parse(typeStringVal);
+                                            break;
+                                        case "side":
+                                            Side = typeStringVal;
+                                            break;
+                                    }
+                                    inType = "";
+                                }
+                            }
+
+                            break;
+
+                        default:
+                            break;
+
+                    }
+                }
+
+                public RomItem.RomTypes? Media { get; set; }
+
+                public int? Number { get; set; }
+
+                public int? Count { get; set; }
+
+                public string? Side { get; set; }
+            }
+        }
    }
 }

--- a/gaseous-server/Models/Signatures_Sources.cs
+++ b/gaseous-server/Models/Signatures_Sources.cs
@@ -0,0 +1,20 @@
+using NuGet.Protocol.Core.Types;
+
+namespace gaseous_server.Models
+{
+    public class Signatures_Sources
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public string URL { get; set; }
+        public string Category { get; set; }
+        public string Version { get; set; }
+        public string Author { get; set; }
+        public string Email { get; set; }
+        public string Homepage { get; set; }
+        public gaseous_signature_parser.parser.SignatureParser SourceType { get; set; }
+        public string MD5 { get; set; }
+        public string SHA1 { get; set; }
+    }
+}
--- a/gaseous-server/Models/UserProfile.cs
+++ b/gaseous-server/Models/UserProfile.cs
@@ -0,0 +1,17 @@
+namespace gaseous_server.Models
+{
+    public class UserProfile
+    {
+        public Guid UserId { get; set; }
+        public string DisplayName { get; set; }
+        public string Quip { get; set; }
+        public ProfileImageItem? Avatar { get; set; }
+        public ProfileImageItem? ProfileBackground { get; set; }
+        public Dictionary<string, object> Data { get; set; }
+        public class ProfileImageItem
+        {
+            public string MimeType { get; set; }
+            public string Extension { get; set; }
+        }
+    }
+}
--- a/gaseous-server/ProcessQueue.cs
+++ b/gaseous-server/ProcessQueue.cs
@@ -245,14 +245,32 @@ namespace gaseous_server
                                        CallingQueueItem = this
                                    };

-                                    Logging.Log(Logging.LogType.Debug, "Signature Import", "Processing TOSEC files");
-                                    tIngest.Import(Path.Combine(Config.LibraryConfiguration.LibrarySignatureImportDirectory, "TOSEC"), gaseous_signature_parser.parser.SignatureParser.TOSEC);
+                                    foreach (int i in Enum.GetValues(typeof(gaseous_signature_parser.parser.SignatureParser)))
+                                    {
+                                        gaseous_signature_parser.parser.SignatureParser parserType = (gaseous_signature_parser.parser.SignatureParser)i;
+                                        if (
+                                            parserType != gaseous_signature_parser.parser.SignatureParser.Auto &&
+                                            parserType != gaseous_signature_parser.parser.SignatureParser.Unknown
+                                        )
+                                        {
+                                            Logging.Log(Logging.LogType.Debug, "Signature Import", "Processing " + parserType + " files");

-                                    Logging.Log(Logging.LogType.Debug, "Signature Import", "Processing MAME Arcade files");
-                                    tIngest.Import(Path.Combine(Config.LibraryConfiguration.LibrarySignatureImportDirectory, "MAME Arcade"), gaseous_signature_parser.parser.SignatureParser.MAMEArcade);
+                                            string SignaturePath = Path.Combine(Config.LibraryConfiguration.LibrarySignaturesDirectory, parserType.ToString());
+                                            string SignatureProcessedPath = Path.Combine(Config.LibraryConfiguration.LibrarySignaturesProcessedDirectory, parserType.ToString());

-                                    Logging.Log(Logging.LogType.Debug, "Signature Import", "Processing MAME MESS files");
-                                    tIngest.Import(Path.Combine(Config.LibraryConfiguration.LibrarySignatureImportDirectory, "MAME MESS"), gaseous_signature_parser.parser.SignatureParser.MAMEMess);
+                                            if (!Directory.Exists(SignaturePath))
+                                            {
+                                                Directory.CreateDirectory(SignaturePath);
+                                            }
+
+                                            if (!Directory.Exists(SignatureProcessedPath))
+                                            {
+                                                Directory.CreateDirectory(SignatureProcessedPath);
+                                            }
+
+                                            tIngest.Import(SignaturePath, SignatureProcessedPath, parserType);
+                                        }
+                                    }

                                    _SaveLastRunTime = true;

--- a/gaseous-server/Program.cs
+++ b/gaseous-server/Program.cs
@@ -36,6 +36,9 @@ db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.Conn

 // set up db
 db.InitDB();
+// create relation tables if they don't exist
+Storage.CreateRelationsTables<IGDB.Models.Game>();
+Storage.CreateRelationsTables<IGDB.Models.Platform>();

 // populate db with static data for lookups
 AgeRatings.PopulateAgeMap();
@@ -64,13 +67,14 @@ if (Directory.Exists(Config.LibraryConfiguration.LibraryUploadDirectory))
 // kick off any delayed upgrade tasks
 // run 1002 background updates in the background on every start
 DatabaseMigration.BackgroundUpgradeTargetSchemaVersions.Add(1002);
+DatabaseMigration.BackgroundUpgradeTargetSchemaVersions.Add(1023);
 // start the task
 ProcessQueue.QueueItem queueItem = new ProcessQueue.QueueItem(
        ProcessQueue.QueueItemType.BackgroundDatabaseUpgrade,
        1,
        new List<ProcessQueue.QueueItemType>
        {
-            ProcessQueue.QueueItemType.All
+            ProcessQueue.QueueItemType.SignatureIngestor
        },
        false,
        true
@@ -307,7 +311,7 @@ app.Use(async (context, next) =>
    string userIdentity;
    try
    {
-        userIdentity = context.User.Claims.Where(x=>x.Type==System.Security.Claims.ClaimTypes.NameIdentifier).FirstOrDefault().Value;
+        userIdentity = context.User.Claims.Where(x => x.Type == System.Security.Claims.ClaimTypes.NameIdentifier).FirstOrDefault().Value;
    }
    catch
    {
@@ -319,72 +323,6 @@ app.Use(async (context, next) =>
    await next();
 });

-// emergency password recovery if environment variable is set
-// process:
-// - set the environment variable "recoveraccount" to the email address of the account to be recovered
-// - when the server starts the password will be reset to a random string and saved in the library
-//   directory with the name RecoverAccount.txt
-// - user should copy this password and remove the "recoveraccount" environment variable and the
-//   RecoverAccount.txt file
-// - the server will not start while the RecoverAccount.txt file exists
-string PasswordRecoveryFile = Path.Combine(Config.LibraryConfiguration.LibraryRootDirectory, "RecoverAccount.txt");
-if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("recoveraccount")))
-{   
-    if (File.Exists(PasswordRecoveryFile))
-    {
-        // password has already been set - do nothing and just exit
-        Logging.Log(Logging.LogType.Critical, "Server Startup", "Unable to start while recoveraccount environment varibale is set and RecoverAccount.txt file exists.", null, true);
-        Environment.Exit(0);
-    }
-    else
-    {
-        // generate and save the password to disk
-        int length = 10;
-        string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+";
-        var random = new Random();
-        string password = new string(Enumerable.Repeat(chars, length).Select(s => s[random.Next(s.Length)]).ToArray());
-
-        File.WriteAllText(PasswordRecoveryFile, password);
-        
-        // reset the password
-        using (var scope = app.Services.CreateScope())
-        {
-            var userManager = scope.ServiceProvider.GetRequiredService<UserStore>();
-            if (await userManager.FindByNameAsync(Environment.GetEnvironmentVariable("recoveraccount"), CancellationToken.None) != null)
-            {
-                ApplicationUser User = await userManager.FindByEmailAsync(Environment.GetEnvironmentVariable("recoveraccount"), CancellationToken.None);
-
-                //set user password
-                PasswordHasher<ApplicationUser> ph = new PasswordHasher<ApplicationUser>();
-                User.PasswordHash = ph.HashPassword(User, password);
-
-                await userManager.SetPasswordHashAsync(User, User.PasswordHash, CancellationToken.None);
-
-                Logging.Log(Logging.LogType.Information, "Server Startup", "Password reset complete, remove the recoveraccount environment variable and RecoverAccount.text file to allow server start.", null, true);
-
-                Environment.Exit(0);
-            }
-            else
-            {
-                Logging.Log(Logging.LogType.Critical, "Server Startup", "Account to recover not found.", null, true);
-
-                Environment.Exit(0);
-            }
-        }
-
-    }
-}
-else
-{
-    // check if RecoverAccount.text file is present
-    if (File.Exists(PasswordRecoveryFile))
-    {
-        // cannot start while password recovery file exists
-        Logging.Log(Logging.LogType.Critical, "Server Startup", "Unable to start while RecoverAccount.txt file exists. Remove the file and try again.", null, true);
-        Environment.Exit(0);
-    }
-}
-
 // setup library directories
 Config.LibraryConfiguration.InitLibrary();

@@ -397,9 +335,6 @@ gaseous_server.Classes.Metadata.Platforms.AssignAllPlatformsToGameIdZero();
 // extract platform map if not present
 PlatformMapping.ExtractPlatformMap();

-// force load platform map into cache
-var platformMap = PlatformMapping.PlatformMap;
-
 // add background tasks
 ProcessQueue.QueueItems.Add(new ProcessQueue.QueueItem(
    ProcessQueue.QueueItemType.SignatureIngestor)
--- a/gaseous-server/Support/Country.txt
+++ b/gaseous-server/Support/Country.txt
@@ -0,0 +1,73 @@
+AE|United Arab Emirates
+AL|Albania
+AS|Asia
+AT|Austria
+AU|Australia
+BA|Bosnia and Herzegovina
+BE|Belgium
+BG|Bulgaria
+BR|Brazil
+CA|Canada
+CH|Switzerland
+CL|Chile
+CN|China
+CS|Serbia and Montenegro
+CY|Cyprus
+CZ|Czech Republic
+DE|Germany
+DK|Denmark
+EE|Estonia
+EG|Egypt
+ES|Spain
+EU|Europe
+FI|Finland
+FR|France
+GB|United Kingdom
+GR|Greece
+HK|Hong Kong
+HR|Croatia
+HU|Hungary
+ID|Indonesia
+IE|Ireland
+IL|Israel
+IN|India
+IR|Iran
+IS|Iceland
+IT|Italy
+JO|Jordan
+JP|Japan
+KR|Korea
+KR|South Korea
+LT|Lithuania
+LU|Luxembourg
+LV|Latvia
+MN|Mongolia
+MX|Mexico
+MY|Malaysia
+NL|Netherlands
+NO|Norway
+NP|Nepal
+NZ|New Zealand
+OM|Oman
+PE|Peru
+PH|Philippines
+PL|Poland
+PT|Portugal
+QA|Qatar
+RO|Romania
+RU|Russia
+SE|Sweden
+SG|Singapore
+SI|Slovenia
+SK|Slovakia
+TH|Thailand
+TR|Turkey
+TW|Taiwan
+US|United States
+USA|United States
+VN|Vietnam
+YU|Yugoslavia
+ZA|South Africa
+World|World
+Europe|Europe
+Asia|Asia
--- a/gaseous-server/Support/Database/MySQL/gaseous-1022.sql
+++ b/gaseous-server/Support/Database/MySQL/gaseous-1022.sql
@@ -0,0 +1 @@
+ALTER TABLE `Platform` CHANGE `Name` `Name` varchar(255);
--- a/gaseous-server/Support/Database/MySQL/gaseous-1023.sql
+++ b/gaseous-server/Support/Database/MySQL/gaseous-1023.sql
@@ -0,0 +1,17 @@
+CREATE TABLE `Country` (
+    `Id` INT NOT NULL AUTO_INCREMENT,
+    `Code` VARCHAR(20) NULL,
+    `Value` VARCHAR(255) NULL,
+    PRIMARY KEY (`Id`),
+    INDEX `id_Code` (`Code` ASC) VISIBLE,
+    INDEX `id_Value` (`Value` ASC) VISIBLE
+);
+
+CREATE TABLE `Language` (
+    `Id` INT NOT NULL AUTO_INCREMENT,
+    `Code` VARCHAR(20) NULL,
+    `Value` VARCHAR(255) NULL,
+    PRIMARY KEY (`Id`),
+    INDEX `id_Code` (`Code` ASC) VISIBLE,
+    INDEX `id_Value` (`Value` ASC) VISIBLE
+);
--- a/gaseous-server/Support/Database/MySQL/gaseous-1024.sql
+++ b/gaseous-server/Support/Database/MySQL/gaseous-1024.sql
@@ -0,0 +1,79 @@
+CREATE TABLE `Signatures_RomToSource` (
+    `SourceId` int NOT NULL,
+    `RomId` int NOT NULL,
+    PRIMARY KEY (`SourceId`, `RomId`)
+);
+
+CREATE TABLE `Signatures_Games_Countries` (
+    `GameId` INT NOT NULL,
+    `CountryId` INT NOT NULL,
+    PRIMARY KEY (`GameId`, `CountryId`),
+    CONSTRAINT `GameCountry` FOREIGN KEY (`GameId`) REFERENCES `Signatures_Games` (`Id`) ON DELETE CASCADE ON UPDATE NO ACTION
+);
+
+CREATE TABLE `Signatures_Games_Languages` (
+    `GameId` INT NOT NULL,
+    `LanguageId` INT NOT NULL,
+    PRIMARY KEY (`GameId`, `LanguageId`),
+    CONSTRAINT `GameLanguage` FOREIGN KEY (`GameId`) REFERENCES `Signatures_Games` (`Id`) ON DELETE CASCADE ON UPDATE NO ACTION
+);
+
+ALTER TABLE `Games_Roms` ADD COLUMN `RomDataVersion` INT DEFAULT 1;
+
+CREATE TABLE UserProfiles (
+    `Id` VARCHAR(45) NOT NULL,
+    `UserId` VARCHAR(45) NOT NULL,
+    `DisplayName` VARCHAR(255) NOT NULL,
+    `Quip` VARCHAR(255) NOT NULL,
+    `Avatar` LONGBLOB,
+    `AvatarExtension` CHAR(6),
+    `ProfileBackground` LONGBLOB,
+    `ProfileBackgroundExtension` CHAR(6),
+    `UnstructuredData` LONGTEXT NOT NULL,
+    PRIMARY KEY (`Id`, `UserId`)
+);
+
+ALTER TABLE `PlatformMap_Bios`
+ADD COLUMN `Enabled` BOOLEAN DEFAULT TRUE;
+
+CREATE TABLE `User_PlatformMap` (
+    `id` VARCHAR(128) NOT NULL,
+    `GameId` BIGINT NOT NULL,
+    `PlatformId` BIGINT NOT NULL,
+    `Mapping` LONGTEXT,
+    PRIMARY KEY (`id`, `GameId`, `PlatformId`),
+    CONSTRAINT `User_PlatformMap_UserId` FOREIGN KEY (`id`) REFERENCES `Users` (`Id`) ON DELETE CASCADE
+);
+
+ALTER TABLE `UserTimeTracking`
+ADD COLUMN `PlatformId` BIGINT,
+ADD COLUMN `IsMediaGroup` BOOLEAN DEFAULT FALSE,
+ADD COLUMN `RomId` BIGINT;
+
+CREATE TABLE `User_RecentPlayedRoms` (
+    `UserId` varchar(128) NOT NULL,
+    `GameId` bigint(20) NOT NULL,
+    `PlatformId` bigint(20) NOT NULL,
+    `RomId` bigint(20) NOT NULL,
+    `IsMediaGroup` tinyint(1) DEFAULT NULL,
+    PRIMARY KEY (
+        `UserId`,
+        `GameId`,
+        `PlatformId`
+    ),
+    CONSTRAINT `RecentPlayedRoms_Users` FOREIGN KEY (`UserId`) REFERENCES `Users` (`Id`) ON DELETE CASCADE
+);
+
+CREATE TABLE `User_GameFavouriteRoms` (
+    `UserId` varchar(128) NOT NULL,
+    `GameId` bigint(20) NOT NULL,
+    `PlatformId` bigint(20) NOT NULL,
+    `RomId` bigint(20) NOT NULL,
+    `IsMediaGroup` tinyint(1) DEFAULT NULL,
+    PRIMARY KEY (
+        `UserId`,
+        `GameId`,
+        `PlatformId`
+    ),
+    CONSTRAINT `GameFavouriteRoms_Users` FOREIGN KEY (`UserId`) REFERENCES `Users` (`Id`) ON DELETE CASCADE
+);
--- a/gaseous-server/Support/Language.txt
+++ b/gaseous-server/Support/Language.txt
@@ -0,0 +1,47 @@
+ar|Arabic
+bg|Bulgarian
+bs|Bosnian
+cs|Czech
+cy|Welsh
+da|Danish
+de|German
+el|Greek
+en|English
+eo|Esperanto
+es|Spanish
+et|Estonian
+fa|Persian
+fi|Finnish
+fr|French
+fr-ca|French Canadian
+ga|Irish
+gd|Gaelic
+gu|Gujarati
+he|Hebrew
+hi|Hindi
+hr|Croatian
+hu|Hungarian
+is|Icelandic
+it|Italian
+ja|Japanese
+ko|Korean
+lt|Lithuanian
+lv|Latvian
+ms|Malay
+nl|Dutch
+no|Norwegian
+pl|Polish
+pt|Portuguese
+ro|Romanian
+ru|Russian
+sk|Slovakian
+sl|Slovenian
+sq|Albanian
+sr|Serbian
+sv|Swedish
+th|Thai
+tr|Turkish
+ur|Urdu
+vi|Vietnamese
+yi|Yiddish
+zh|Chinese
--- a/gaseous-server/Support/PlatformMap.json
+++ b/gaseous-server/Support/PlatformMap.json
--- a/gaseous-server/gaseous-server.csproj
+++ b/gaseous-server/gaseous-server.csproj
@@ -16,20 +16,20 @@
    <DocumentationFile>bin\Release\net8.0\gaseous-server.xml</DocumentationFile>
  </PropertyGroup>
  <ItemGroup>
-    <PackageReference Include="Asp.Versioning.Mvc" Version="8.0.0" />
-    <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.0.0" />
-    <PackageReference Include="gaseous-signature-parser" Version="2.1.0" />
+    <PackageReference Include="Asp.Versioning.Mvc" Version="8.1.0" />
+    <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.1.0" />
+    <PackageReference Include="gaseous-signature-parser" Version="2.2.1" />
    <PackageReference Include="gaseous.IGDB" Version="1.0.2" />
-    <PackageReference Include="hasheous-client" Version="0.2.0" />
-    <PackageReference Include="Magick.NET-Q8-AnyCPU" Version="13.5.0" />
-    <PackageReference Include="sharpcompress" Version="0.36.0" />
-    <PackageReference Include="Squid-Box.SevenZipSharp" Version="1.6.1.23" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
-    <PackageReference Include="MySqlConnector" Version="2.3.5" />
-    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="8.0.1" />
-    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.1" />
+    <PackageReference Include="hasheous-client" Version="1.0.2" />
+    <PackageReference Include="Magick.NET-Q8-AnyCPU" Version="14.0.0" />
+    <PackageReference Include="sharpcompress" Version="0.37.2" />
+    <PackageReference Include="Squid-Box.SevenZipSharp" Version="1.6.2.24" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.1" />
+    <PackageReference Include="MySqlConnector" Version="2.3.7" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="8.0.5" />
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.5" />
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
-    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="8.0.0" />
+    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="8.0.2" />
    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
  </ItemGroup>
  <ItemGroup>
@@ -39,6 +39,8 @@
    <None Remove="Classes\" />
    <None Remove="Classes\SignatureIngestors\" />
    <None Remove="Support\" />
+    <None Remove="Support\Country.txt" />
+    <None Remove="Support\Language.txt" />
    <None Remove="Support\Database\" />
    <None Remove="Support\Database\MySQL\" />
    <None Remove="Support\Database\MySQL\gaseous-1000.sql" />
@@ -64,6 +66,9 @@
    <None Remove="Support\Database\MySQL\gaseous-1019.sql" />
    <None Remove="Support\Database\MySQL\gaseous-1020.sql" />
    <None Remove="Support\Database\MySQL\gaseous-1021.sql" />
+    <None Remove="Support\Database\MySQL\gaseous-1022.sql" />
+    <None Remove="Support\Database\MySQL\gaseous-1023.sql" />
+    <None Remove="Support\Database\MySQL\gaseous-1024.sql" />
    <None Remove="Classes\Metadata\" />
  </ItemGroup>
  <ItemGroup>
@@ -85,6 +90,8 @@
      <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
      <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
    </EmbeddedResource>
+    <EmbeddedResource Include="Support\Country.txt" />
+    <EmbeddedResource Include="Support\Language.txt" />
    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1000.sql" />
    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1001.sql" />
    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1002.sql" />
@@ -108,5 +115,8 @@
    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1019.sql" />
    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1020.sql" />
    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1021.sql" />
+    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1022.sql" />
+    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1023.sql" />
+    <EmbeddedResource Include="Support\Database\MySQL\gaseous-1024.sql" />
  </ItemGroup>
 </Project>
--- a/gaseous-server/wwwroot/.DS_Store
+++ b/gaseous-server/wwwroot/.DS_Store
--- a/gaseous-server/wwwroot/emulators/EmulatorJS.html
+++ b/gaseous-server/wwwroot/emulators/EmulatorJS.html
@@ -22,9 +22,11 @@
    if (StateUrl) {
        console.log('Loading saved state from: ' + StateUrl);
        EJS_loadStateURL = StateUrl;
-        EJS_startOnLoaded = true;
    }

+    // start the emulator automatically when loaded
+    EJS_startOnLoaded = true;
+
    // Path to the data directory
    EJS_pathtodata = '/emulators/EmulatorJS/data/';

@@ -42,10 +44,11 @@

    EJS_Buttons = {
        saveSavFiles: false,
-        loadSavFiles: false
+        loadSavFiles: false,
+        exitEmulation: false
    }

-    EJS_onSaveState = function(e) {
+    EJS_onSaveState = function (e) {
        var returnValue = {
            "ScreenshotByteArrayBase64": btoa(Uint8ToString(e.screenshot)),
            "StateByteArrayBase64": btoa(Uint8ToString(e.state))
@@ -72,8 +75,12 @@
        returnValue = undefined;
    }

-    EJS_onLoadState = function(e) {
-        showDialog('emulatorloadstate', { "romId": romId, "IsMediaGroup": IsMediaGroup });
+    EJS_onLoadState = function (e) {
+        let rompath = decodeURIComponent(getQueryString('rompath', 'string'));
+        rompath = rompath.substring(rompath.lastIndexOf('/') + 1);
+        console.log(rompath);
+        let stateManager = new EmulatorStateManager(romId, IsMediaGroup, getQueryString('engine', 'string'), getQueryString('core', 'string'), platformId, gameId, rompath);
+        stateManager.open();
    }
 </script>
 <script src='/emulators/EmulatorJS/data/loader.js'></script>
--- a/gaseous-server/wwwroot/images/Critical.svg
+++ b/gaseous-server/wwwroot/images/Critical.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 48 48" xmlns="http://www.w3.org/2000/svg">
+  <title>stop-warning</title>
+  <g id="Layer_2" data-name="Layer 2">
+    <g id="invisible_box" data-name="invisible box">
+      <rect width="48" height="48" fill="none"/>
+    </g>
+    <g id="icons_Q2" data-name="icons Q2">
+      <g>
+        <path d="M43.4,15.1,32.9,4.6A2,2,0,0,0,31.5,4h-15a2,2,0,0,0-1.4.6L4.6,15.1A2,2,0,0,0,4,16.5v15a2,2,0,0,0,.6,1.4L15.1,43.4a2,2,0,0,0,1.4.6h15a2,2,0,0,0,1.4-.6L43.4,32.9a2,2,0,0,0,.6-1.4v-15A2,2,0,0,0,43.4,15.1ZM40,30.6,30.6,40H17.4L8,30.6V17.4L17.4,8H30.6L40,17.4Z"/>
+        <path d="M26.8,24l5.6-5.6a2,2,0,0,0-2.8-2.8L24,21.2l-5.6-5.6a2,2,0,0,0-2.8,2.8L21.2,24l-5.6,5.6a1.9,1.9,0,0,0,0,2.8,1.9,1.9,0,0,0,2.8,0L24,26.8l5.6,5.6a1.9,1.9,0,0,0,2.8,0,1.9,1.9,0,0,0,0-2.8Z"/>
+      </g>
+    </g>
+  </g>
--- a/gaseous-server/wwwroot/images/NoIntro-logo.svg
+++ b/gaseous-server/wwwroot/images/NoIntro-logo.svg
--- a/gaseous-server/wwwroot/images/Ratings/ESRB/EC.svg
+++ b/gaseous-server/wwwroot/images/Ratings/ESRB/EC.svg
--- a/gaseous-server/wwwroot/images/Warning.svg
+++ b/gaseous-server/wwwroot/images/Warning.svg
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 48 48" xmlns="http://www.w3.org/2000/svg">
+  <title>warning</title>
+  <g id="Layer_2" data-name="Layer 2">
+    <g id="invisible_box" data-name="invisible box">
+      <rect width="48" height="48" fill="none"/>
+    </g>
+    <g id="icons_Q2" data-name="icons Q2">
+      <g>
+        <path d="M24,9,40.6,39H7.5L24,9M2.3,40A2,2,0,0,0,4,43H44a2,2,0,0,0,1.7-3L25.7,4a2,2,0,0,0-3.4,0Z"/>
+        <path d="M22,19v9a2,2,0,0,0,4,0V19a2,2,0,0,0-4,0Z"/>
+        <circle cx="24" cy="34" r="2"/>
+      </g>
+    </g>
+  </g>
--- a/gaseous-server/wwwroot/images/arrow-down.svg
+++ b/gaseous-server/wwwroot/images/arrow-down.svg
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" height="800px" width="800px" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
+	 viewBox="0 0 512.011 512.011" xml:space="preserve">
+<g>
+	<g>
+		<path d="M505.755,123.592c-8.341-8.341-21.824-8.341-30.165,0L256.005,343.176L36.421,123.592c-8.341-8.341-21.824-8.341-30.165,0
+			s-8.341,21.824,0,30.165l234.667,234.667c4.16,4.16,9.621,6.251,15.083,6.251c5.462,0,10.923-2.091,15.083-6.251l234.667-234.667
+			C514.096,145.416,514.096,131.933,505.755,123.592z"/>
+	</g>
+</g>
+</svg>
--- a/gaseous-server/wwwroot/images/arrow-left.svg
+++ b/gaseous-server/wwwroot/images/arrow-left.svg
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" height="800px" width="800px" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
+	 viewBox="0 0 512.006 512.006" xml:space="preserve">
+<g>
+	<g>
+		<path d="M388.419,475.59L168.834,256.005L388.418,36.421c8.341-8.341,8.341-21.824,0-30.165s-21.824-8.341-30.165,0
+			L123.586,240.923c-8.341,8.341-8.341,21.824,0,30.165l234.667,234.667c4.16,4.16,9.621,6.251,15.083,6.251
+			c5.461,0,10.923-2.091,15.083-6.251C396.76,497.414,396.76,483.931,388.419,475.59z"/>
+	</g>
+</g>
+</svg>
--- a/gaseous-server/wwwroot/images/arrow-right.svg
+++ b/gaseous-server/wwwroot/images/arrow-right.svg
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" height="800px" width="800px" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
+	 viewBox="0 0 512.005 512.005" xml:space="preserve">
+<g>
+	<g>
+		<path d="M388.418,240.923L153.751,6.256c-8.341-8.341-21.824-8.341-30.165,0s-8.341,21.824,0,30.165L343.17,256.005
+			L123.586,475.589c-8.341,8.341-8.341,21.824,0,30.165c4.16,4.16,9.621,6.251,15.083,6.251c5.461,0,10.923-2.091,15.083-6.251
+			l234.667-234.667C396.759,262.747,396.759,249.264,388.418,240.923z"/>
+	</g>
+</g>
+</svg>
--- a/gaseous-server/wwwroot/images/arrow-up.svg
+++ b/gaseous-server/wwwroot/images/arrow-up.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg fill="#000000" height="800px" width="800px" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
+	 viewBox="0 0 512 512" xml:space="preserve">
+<g>
+	<g>
+		<path d="M505.752,358.248L271.085,123.582c-8.331-8.331-21.839-8.331-30.17,0L6.248,358.248c-8.331,8.331-8.331,21.839,0,30.17
+			s21.839,8.331,30.17,0L256,168.837l219.582,219.582c8.331,8.331,21.839,8.331,30.17,0S514.083,366.58,505.752,358.248z"/>
+	</g>
+</g>
+</svg>
--- a/gaseous-server/wwwroot/images/bios.svg
+++ b/gaseous-server/wwwroot/images/bios.svg
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
+	 viewBox="0 0 512 512" xml:space="preserve">
+<g>
+	<rect x="342.232" y="460.8" style="fill:#AFB6BB;" width="43.116" height="37.726"/>
+	<rect x="234.442" y="460.8" style="fill:#AFB6BB;" width="43.116" height="37.726"/>
+	<rect x="126.653" y="460.8" style="fill:#AFB6BB;" width="43.116" height="37.726"/>
+	<rect x="8.084" y="234.442" style="fill:#AFB6BB;" width="43.116" height="43.116"/>
+	<rect x="8.084" y="342.232" style="fill:#AFB6BB;" width="43.116" height="43.116"/>
+	<rect x="460.8" y="342.232" style="fill:#AFB6BB;" width="43.116" height="43.116"/>
+	<rect x="460.8" y="234.442" style="fill:#AFB6BB;" width="43.116" height="43.116"/>
+	<rect x="460.8" y="126.653" style="fill:#AFB6BB;" width="43.116" height="43.116"/>
+	<rect x="342.232" y="13.474" style="fill:#AFB6BB;" width="43.116" height="37.726"/>
+	<rect x="234.442" y="13.474" style="fill:#AFB6BB;" width="43.116" height="37.726"/>
+	<rect x="126.653" y="13.474" style="fill:#AFB6BB;" width="43.116" height="37.726"/>
+	<rect x="8.084" y="126.653" style="fill:#AFB6BB;" width="43.116" height="43.116"/>
+</g>
+<g>
+	<rect x="51.2" y="126.653" style="fill:#E7ECED;" width="32.337" height="43.116"/>
+	<rect x="51.2" y="234.442" style="fill:#E7ECED;" width="32.337" height="43.116"/>
+	<rect x="51.2" y="342.232" style="fill:#E7ECED;" width="32.337" height="43.116"/>
+	<rect x="126.653" y="428.463" style="fill:#E7ECED;" width="43.116" height="32.337"/>
+	<rect x="234.442" y="428.463" style="fill:#E7ECED;" width="43.116" height="32.337"/>
+	<rect x="342.232" y="428.463" style="fill:#E7ECED;" width="43.116" height="32.337"/>
+	<rect x="428.463" y="342.232" style="fill:#E7ECED;" width="32.337" height="43.116"/>
+	<rect x="428.463" y="234.442" style="fill:#E7ECED;" width="32.337" height="43.116"/>
+	<rect x="428.463" y="126.653" style="fill:#E7ECED;" width="32.337" height="43.116"/>
+	<rect x="342.232" y="51.2" style="fill:#E7ECED;" width="43.116" height="32.337"/>
+	<rect x="234.442" y="51.2" style="fill:#E7ECED;" width="43.116" height="32.337"/>
+	<rect x="126.653" y="51.2" style="fill:#E7ECED;" width="43.116" height="32.337"/>
+</g>
+<path style="fill:#595E62;" d="M428.463,385.347v32.337c0,5.928-4.851,10.779-10.779,10.779h-32.337h-43.116h-64.674h-43.116
+	h-64.674h-43.116H94.316c-5.928,0-10.779-4.851-10.779-10.779v-32.337v-43.116v-64.674v-43.116v-64.674v-43.116V94.316
+	c0-5.928,4.851-10.779,10.779-10.779h32.337h43.116h64.674h43.116h64.674h43.116h32.337c5.928,0,10.779,4.851,10.779,10.779v32.337
+	v43.116v64.674v43.116v64.674V385.347z M385.347,385.347V126.653H126.653v258.695H385.347z"/>
+<rect x="126.653" y="126.653" style="fill:#36C63F;" width="258.695" height="258.695"/>
+<path style="fill:#00AB4E;" d="M173.785,126.653h-47.132v258.695h258.695v-47.132C284.709,306.659,205.341,227.291,173.785,126.653z
+	"/>
+<path style="fill:#44494C;" d="M126.653,385.347V126.653H256V83.537h-21.558h-64.674h-43.116H94.316
+	c-5.928,0-10.779,4.851-10.779,10.779v32.337v43.116v64.674v43.116v64.674v43.116v32.337c0,5.928,4.851,10.779,10.779,10.779h32.337
+	h43.116h64.674H256v-43.116H126.653z"/>
+<g>
+	<rect x="180.547" y="161.684" style="fill:#FFFFFF;" width="150.905" height="16.168"/>
+	<rect x="180.547" y="237.137" style="fill:#FFFFFF;" width="150.905" height="16.168"/>
+	<rect x="180.547" y="199.411" style="fill:#FFFFFF;" width="26.947" height="16.168"/>
+	<rect x="180.547" y="334.147" style="fill:#FFFFFF;" width="26.947" height="16.168"/>
+	<rect x="223.663" y="334.147" style="fill:#FFFFFF;" width="26.947" height="16.168"/>
+	<rect x="299.116" y="334.147" style="fill:#FFFFFF;" width="26.947" height="16.168"/>
+	<rect x="239.832" y="199.411" style="fill:#FFFFFF;" width="91.621" height="16.168"/>
+</g>
+<path d="M118.568,393.432h274.863V118.568H118.568V393.432z M134.737,134.737h242.526v242.526H134.737V134.737z"/>
+<path d="M512,177.853v-59.284h-75.453V94.316c0-10.401-8.463-18.863-18.863-18.863h-24.253V5.389h-59.284v70.063h-48.505V5.389
+	h-59.284v70.063h-48.505V5.389h-59.284v70.063H94.316c-10.401,0-18.863,8.463-18.863,18.863v24.253H0v59.284h75.453v48.505H0v59.284
+	h75.453v48.505H0v59.284h75.453v24.253c0,10.401,8.463,18.863,18.863,18.863h24.253v70.063h59.284v-70.063h48.505v70.063h59.284
+	v-70.063h48.505v70.063h59.284v-70.063h24.253c10.401,0,18.863-8.463,18.863-18.863v-24.253H512v-59.284h-75.453v-48.505H512
+	v-59.284h-75.453v-48.505H512z M436.547,134.737h16.168v26.947h-16.168V134.737z M495.832,161.684h-26.947v-26.947h26.947V161.684z
+	 M350.316,59.284h26.947v16.168h-26.947V59.284z M377.263,21.558v21.558h-26.947V21.558H377.263z M242.526,59.284h26.947v16.168
+	h-26.947V59.284z M269.474,21.558v21.558h-26.947V21.558H269.474z M134.737,59.284h26.947v16.168h-26.947V59.284z M161.684,21.558
+	v21.558h-26.947V21.558H161.684z M75.453,161.684H59.284v-26.947h16.168V161.684z M16.168,134.737h26.947v26.947H16.168V134.737z
+	 M75.453,269.474H59.284v-26.947h16.168V269.474z M16.168,242.526h26.947v26.947H16.168V242.526z M75.453,377.263H59.284v-26.947
+	h16.168V377.263z M16.168,350.316h26.947v26.947H16.168V350.316z M161.684,452.716h-26.947v-16.168h26.947V452.716z
+	 M134.737,490.442v-21.558h26.947v21.558H134.737z M269.474,452.716h-26.947v-16.168h26.947V452.716z M242.526,490.442v-21.558
+	h26.947v21.558H242.526z M377.263,452.716h-26.947v-16.168h26.947V452.716z M350.316,490.442v-21.558h26.947v21.558H350.316z
+	 M436.547,350.316h16.168v26.947h-16.168V350.316z M495.832,377.263h-26.947v-26.947h26.947V377.263z M436.547,242.526h16.168
+	v26.947h-16.168V242.526z M495.832,269.474h-26.947v-26.947h26.947V269.474z M420.379,417.684c0,1.461-1.234,2.695-2.695,2.695
+	H94.316c-1.461,0-2.695-1.234-2.695-2.695V94.316c0-1.461,1.234-2.695,2.695-2.695h323.368c1.461,0,2.695,1.234,2.695,2.695V417.684
+	z"/>
+</svg>
--- a/gaseous-server/wwwroot/images/cross.svg
+++ b/gaseous-server/wwwroot/images/cross.svg
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 32 32" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns">
+    
+    <title>cross-circle</title>
+    <desc>Created with Sketch Beta.</desc>
+    <defs>
+
+</defs>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd" sketch:type="MSPage">
+        <g id="Icon-Set" sketch:type="MSLayerGroup" transform="translate(-568.000000, -1087.000000)" fill="red">
+            <path d="M584,1117 C576.268,1117 570,1110.73 570,1103 C570,1095.27 576.268,1089 584,1089 C591.732,1089 598,1095.27 598,1103 C598,1110.73 591.732,1117 584,1117 L584,1117 Z M584,1087 C575.163,1087 568,1094.16 568,1103 C568,1111.84 575.163,1119 584,1119 C592.837,1119 600,1111.84 600,1103 C600,1094.16 592.837,1087 584,1087 L584,1087 Z M589.717,1097.28 C589.323,1096.89 588.686,1096.89 588.292,1097.28 L583.994,1101.58 L579.758,1097.34 C579.367,1096.95 578.733,1096.95 578.344,1097.34 C577.953,1097.73 577.953,1098.37 578.344,1098.76 L582.58,1102.99 L578.314,1107.26 C577.921,1107.65 577.921,1108.29 578.314,1108.69 C578.708,1109.08 579.346,1109.08 579.74,1108.69 L584.006,1104.42 L588.242,1108.66 C588.633,1109.05 589.267,1109.05 589.657,1108.66 C590.048,1108.27 590.048,1107.63 589.657,1107.24 L585.42,1103.01 L589.717,1098.71 C590.11,1098.31 590.11,1097.68 589.717,1097.28 L589.717,1097.28 Z" id="cross-circle" sketch:type="MSShapeGroup">
+
+</path>
+        </g>
+    </g>
+</svg>
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				ALTER TABLE `Platform` CHANGE `Name` `Name` varchar(255);