diff --git a/client/package.json b/client/package.json
index 3fbac0f4f..da9b2d1d5 100644
--- a/client/package.json
+++ b/client/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-media-annotator",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "author": {
     "name": "Kitware, Inc.",
     "email": "viame-web@kitware.com"
@@ -16,7 +16,7 @@
     "build:cli": "tsc -p tsconfig.cli.json",
     "lint": "vue-cli-service lint src/ viame-web-common/ platform/",
     "lint:templates": "vtc --workspace . --srcDir src/",
-    "test": "vue-cli-service test:unit src/ viame-web-common/",
+    "test": "vue-cli-service test:unit src/ viame-web-common/ platform/",
     "serialize": "ts-node --project tsconfig.cli.json platform/desktop/backend/serializers/cli.ts"
   },
   "resolutions": {
@@ -55,13 +55,17 @@
   },
   "devDependencies": {
     "@types/axios": "^0.14.0",
+    "@types/body-parser": "^1.19.0",
+    "@types/cors": "^2.8.9",
     "@types/csv-parse": "^1.2.2",
     "@types/d3": "^5.7.2",
     "@types/electron-devtools-installer": "^2.2.0",
+    "@types/express": "^4.17.9",
     "@types/geojson": "^7946.0.7",
     "@types/jest": "^25.2.3",
     "@types/lodash": "^4.14.151",
     "@types/mime-types": "^2.1.0",
+    "@types/mock-fs": "^4.13.0",
     "@types/node": "^14.0.5",
     "@types/pump": "^1.1.0",
     "@types/range-parser": "^1.2.3",
@@ -81,6 +85,8 @@
     "babel-eslint": "^10.1.0",
     "babel-jest": "^26.0.1",
     "babel-register": "^6.26.0",
+    "body-parser": "^1.19.0",
+    "cors": "^2.8.5",
     "csv-parse": "^4.13.1",
     "electron": "^10.1.3",
     "electron-devtools-installer": "^3.1.1",
@@ -88,11 +94,13 @@
     "eslint-import-resolver-typescript": "^2.2.0",
     "eslint-plugin-import": "^2.20.2",
     "eslint-plugin-vue": "^6.2.2",
+    "express": "^4.17.1",
     "fs-extra": "^9.0.1",
     "git-describe": "^4.0.4",
     "jest": "^26.0.1",
     "jest-transform-stub": "^2.0.0",
     "mime-types": "^2.1.27",
+    "mock-fs": "^4.13.0",
     "pump": "^3.0.0",
     "range-parser": "^1.2.1",
     "request": "^2.88.2",
@@ -121,6 +129,7 @@
     "moduleNameMapper": {
       "^vue-media-annotator/(.*)$": "<rootDir>/src/$1",
       "^viame-web-common/(.*)$": "<rootDir>/viame-web-common/$1",
+      "^platform/(.*)$": "<rootDir>/platform/$1",
       "\\.css$": "<rootDir>/test/stub.js"
     },
     "transform": {
diff --git a/client/platform/desktop/App.vue b/client/platform/desktop/App.vue
index 557983f29..a599479c3 100644
--- a/client/platform/desktop/App.vue
+++ b/client/platform/desktop/App.vue
@@ -7,7 +7,7 @@
 <script lang="ts">
 import { defineComponent } from '@vue/composition-api';
 import { provideApi } from 'viame-web-common/apispec';
-import statefulApi from './store';
+import statefulApi from './frontend/store';
 
 export default defineComponent({
   name: 'App',
diff --git a/client/platform/desktop/api/main.ts b/client/platform/desktop/api/main.ts
deleted file mode 100644
index eeec85a90..000000000
--- a/client/platform/desktop/api/main.ts
+++ /dev/null
@@ -1,167 +0,0 @@
-import { AddressInfo } from 'net';
-import path from 'path';
-
-import { ipcRenderer, remote, FileFilter } from 'electron';
-import fs from 'fs-extra';
-import mime from 'mime-types';
-
-import {
-  Attribute,
-  DatasetMetaMutable,
-  DatasetType, FrameImage,
-  Pipe,
-  Pipelines, TrainingConfigs,
-} from 'viame-web-common/apispec';
-
-import common from '../backend/platforms/common';
-import {
-  DesktopJob, NvidiaSmiReply, RunPipeline,
-  websafeImageTypes, websafeVideoTypes,
-  DesktopDataset, Settings,
-} from '../constants';
-
-const { loadDetections, saveDetections } = common;
-
-function mediaServerInfo(): Promise<AddressInfo> {
-  return ipcRenderer.invoke('info');
-}
-
-function nvidiaSmi(): Promise<NvidiaSmiReply> {
-  return ipcRenderer.invoke('nvidia-smi');
-}
-
-function openLink(url: string): Promise<void> {
-  return ipcRenderer.invoke('open-link-in-browser', url);
-}
-
-async function openFromDisk(datasetType: DatasetType) {
-  let filters: FileFilter[] = [];
-  if (datasetType === 'video') {
-    filters = [
-      { name: 'Videos', extensions: websafeVideoTypes.map((str) => str.split('/')[1]) },
-    ];
-  }
-  const results = await remote.dialog.showOpenDialog({
-    properties: [datasetType === 'video' ? 'openFile' : 'openDirectory'],
-    filters,
-  });
-  return results;
-}
-
-async function getAttributes() {
-  return Promise.resolve([] as Attribute[]);
-}
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-async function setAttribute({ addNew, data }: {addNew: boolean | undefined; data: Attribute}) {
-  return Promise.resolve();
-}
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-async function deleteAttribute(data: Attribute) {
-  return Promise.resolve([] as Attribute[]);
-}
-
-async function getPipelineList(settings: Settings): Promise<Pipelines> {
-  return ipcRenderer.invoke('get-pipeline-list', settings);
-}
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-async function getTrainingConfigurations(): Promise<TrainingConfigs> {
-  return Promise.resolve({ configs: [], default: '' });
-}
-
-async function runTraining(
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  folderIds: string[], pipelineName: string, config: string,
-): Promise<unknown> {
-  return Promise.resolve();
-}
-
-async function loadMetadata(datasetId: string): Promise<DesktopDataset> {
-  let datasetType = undefined as 'video' | 'image-sequence' | undefined;
-  let videoUrl = '';
-  let videoPath = '';
-  let basePath = datasetId; // default to image-sequence type basepath
-  const imageData = [] as FrameImage[];
-  const serverInfo = await mediaServerInfo();
-
-  function processFile(abspath: string) {
-    const basename = path.basename(abspath);
-    const abspathuri = `http://localhost:${serverInfo.port}/api/media?path=${abspath}`;
-    const mimetype = mime.lookup(abspath);
-    if (mimetype && websafeVideoTypes.includes(mimetype)) {
-      datasetType = 'video';
-      basePath = path.dirname(datasetId); // parent directory of video;
-      videoPath = abspath;
-      videoUrl = abspathuri;
-    } else if (mimetype && websafeImageTypes.includes(mimetype)) {
-      datasetType = 'image-sequence';
-      imageData.push({
-        url: abspathuri,
-        filename: basename,
-      });
-    }
-  }
-
-  const info = await fs.stat(datasetId);
-
-  if (info.isDirectory()) {
-    const contents = await fs.readdir(datasetId);
-    for (let i = 0; i < contents.length; i += 1) {
-      processFile(path.join(datasetId, contents[i]));
-    }
-  } else {
-    processFile(datasetId);
-  }
-
-  if (datasetType === undefined) {
-    throw new Error(`Cannot open dataset ${datasetId}: No images or video found`);
-  }
-
-  return Promise.resolve({
-    name: path.basename(datasetId),
-    basePath,
-    videoPath,
-    meta: {
-      type: datasetType,
-      fps: 10,
-      imageData: datasetType === 'image-sequence' ? imageData : [],
-      videoUrl: datasetType === 'video' ? videoUrl : undefined,
-    },
-  });
-}
-
-// eslint-disable-next-line
-async function saveMetadata(datasetId: string, metadata: DatasetMetaMutable) {
-  return Promise.resolve();
-}
-
-async function runPipeline(itemId: string, pipeline: Pipe, settings: Settings) {
-  const args: RunPipeline = {
-    pipelineName: pipeline.name,
-    datasetId: itemId,
-    settings,
-  };
-  const job: DesktopJob = await ipcRenderer.invoke('run-pipeline', args);
-  return job;
-}
-
-export {
-  /* Standard common APIs */
-  getAttributes,
-  setAttribute,
-  deleteAttribute,
-  getPipelineList,
-  runPipeline,
-  getTrainingConfigurations,
-  runTraining,
-  loadDetections,
-  saveDetections,
-  loadMetadata,
-  saveMetadata,
-  /* Nonstandard APIs */
-  openFromDisk,
-  openLink,
-  nvidiaSmi,
-};
diff --git a/client/platform/desktop/backend/ipcService.ts b/client/platform/desktop/backend/ipcService.ts
index e5d1fa9b2..c5ad3eb96 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -1,57 +1,60 @@
 import OS from 'os';
-
+import http from 'http';
 import { ipcMain } from 'electron';
-import { DesktopJobUpdate, RunPipeline, Settings } from '../constants';
 
-import server from './server';
-import linux from './platforms/linux';
-import win32 from './platforms/windows';
-import common from './platforms/common';
+import { DesktopJobUpdate, RunPipeline, Settings } from 'platform/desktop/constants';
 
-export default function register() {
-  ipcMain.handle('info', () => {
-    const addr = server.address();
-    return addr;
-  });
+import linux from './native/linux';
+import win32 from './native/windows';
+import common from './native/common';
+import settings from './state/settings';
+import { listen } from './server';
+
+// defaults to linux if win32 doesn't exist
+const currentPlatform = OS.platform() === 'win32' ? win32 : linux;
+if (OS.platform() === 'win32') {
+  win32.initialize();
+}
 
+export default function register() {
   /**
    * Platform-agnostic methods
    */
-
-  ipcMain.handle('get-pipeline-list', async (_, settings: Settings) => {
-    const ret = await common.getPipelineList(settings);
+  ipcMain.handle('server-info', async () => {
+    const server = await new Promise<http.Server>((resolve) => listen(resolve));
+    return server.address();
+  });
+  ipcMain.handle('get-pipeline-list', async () => {
+    const ret = await common.getPipelineList(settings.get());
     return ret;
   });
   ipcMain.handle('open-link-in-browser', (_, url: string) => {
     common.openLink(url);
   });
+  ipcMain.on('update-settings', async (_, s: Settings) => {
+    settings.set(s);
+  });
 
   /**
    * Platform-dependent methods
    */
 
-  // defaults to linux if win32 doesn't exist
-  const currentPlatform = OS.platform() === 'win32' ? win32 : linux;
-  if (OS.platform() === 'win32') {
-    win32.initialize();
-  }
   ipcMain.handle('nvidia-smi', async () => {
     const ret = await currentPlatform.nvidiaSmi();
     return ret;
   });
-
   ipcMain.handle('default-settings', async () => {
     const defaults = currentPlatform.DefaultSettings;
     return defaults;
   });
-  ipcMain.handle('validate-settings', async (_, settings: Settings) => {
-    const ret = await currentPlatform.validateViamePath(settings);
+  ipcMain.handle('validate-settings', async (_, s: Settings) => {
+    const ret = await currentPlatform.validateViamePath(s);
     return ret;
   });
   ipcMain.handle('run-pipeline', async (event, args: RunPipeline) => {
     const updater = (update: DesktopJobUpdate) => {
       event.sender.send('job-update', update);
     };
-    return currentPlatform.runPipeline(args, updater);
+    return currentPlatform.runPipeline(settings.get(), args, updater);
   });
 }
diff --git a/client/platform/desktop/backend/native/common.spec.ts b/client/platform/desktop/backend/native/common.spec.ts
new file mode 100644
index 000000000..3f822e660
--- /dev/null
+++ b/client/platform/desktop/backend/native/common.spec.ts
@@ -0,0 +1,261 @@
+/// <reference types="jest" />
+import mockfs from 'mock-fs';
+import npath from 'path';
+import fs from 'fs-extra';
+import { Console } from 'console';
+
+import type { JsonMeta, Settings } from 'platform/desktop/constants';
+
+import common from './common';
+
+const pipelines = {
+  'classify_detections_svm.pipe': '',
+  'common_generic_detector_with_filter.pipe': '',
+  'common_image_stabilizer.pipe': '',
+  'common_short_term_tracker.pipe': '',
+  'common_stabilized_iou_tracker.pipe': '',
+  'database_apply_svm_models.pipe': '',
+  'detector_default.pipe': '',
+  'detector_extract_chips.pipe': '',
+  'detector_generic.pipe': '',
+  'detector_local.pipe': '',
+  'detector_local_left.pipe': '',
+  'detector_simple_hough.pipe': '',
+  'detector_svm_models.pipe': '',
+  'display_annotations.pipe': '',
+  'draw_detections_on_images.pipe': '',
+  'extract_chips_from_detections.pipe': '',
+  'filter_debayer_and_enhance.pipe': '',
+  'filter_enhance.pipe': '',
+  'filter_extract_left.pipe': '',
+  'filter_split_and_debayer.pipe': '',
+  'filter_to_kwa.pipe': '',
+  'full_frame_classifier_local.pipe': '',
+  'full_frame_classifier_svm.pipe': '',
+  'generate_empty_frame_lbls_1fr.pipe': '',
+  'generate_empty_frame_lbls_10fr.pipe': '',
+  'generate_empty_frame_lbls_100fr.pipe': '',
+  'generate_empty_frame_lbls_1000fr.pipe': '',
+  'index_default.pipe': '',
+  'index_default.svm.pipe': '',
+  'index_default.trk.pipe': '',
+  'index_existing.pipe': '',
+  'smqtk_query.pipe': '',
+  'smqtk_train_itq.json': '',
+  'sql_init_table.sql': '',
+  'tracker_default.pipe': '',
+  'tracker_default.sfd.pipe': '',
+  'tracker_generic.pipe': '',
+  'tracker_local.pipe': '',
+  'tracker_short_term.pipe': '',
+  'tracker_stabilized_iou.pipe': '',
+  'tracker_svm_models.pipe': '',
+  'train_color_freq_aug.pipe': '',
+  'train_hue_shifting_only_aug.pipe': '',
+  'train_intensity_color_freq_motion_aug.pipe': '',
+  'train_intensity_hue_motion_aug.pipe': '',
+  'train_mmdet_cascade.habcam.conf': '',
+  'train_mmdet_cascade.viame_csv.conf': '',
+  'train_mmdet_cascade_icm.viame_csv.conf': '',
+  'train_mmdet_cascade_ihm.viame_csv.conf': '',
+  'train_motion_and_color_freq_aug.pipe': '',
+  'train_motion_aug.pipe': '',
+  'train_netharn_cascade.habcam.conf': '',
+  'train_netharn_cascade.viame_csv.conf': '',
+};
+
+const settings: Settings = {
+  version: 1,
+  dataPath: '/home/user/viamedata',
+  viamePath: '/opt/viame',
+};
+const urlMapper = (a: string) => `http://localhost:8888/api/media?path=${a}`;
+
+// https://github.com/tschaub/mock-fs/issues/234
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const console = new Console(process.stdout, process.stderr);
+
+mockfs({
+  '/opt/viame': {
+    configs: {
+      pipelines: {
+        models: {},
+        templates: {},
+        ...pipelines,
+      },
+    },
+  },
+  '/home/user/data': {
+    imageSuccess: {
+      'foo.png': '',
+      'bar.png': '',
+      notanimage: '',
+      'notanimage.txt': '',
+    },
+    videoSuccess: {
+      'video1.avi': '',
+      'video1.mp4': '',
+      'otherfile.txt': '',
+      nomime: '',
+    },
+    annotationFail: {
+      'video1.mp4': '',
+      'file1.csv': '',
+      'file2.csv': '',
+    },
+  },
+  '/home/user/viamedata': {
+    // eslint-disable-next-line @typescript-eslint/camelcase
+    DIVE_Jobs: {
+      /* Empty */
+    },
+    // eslint-disable-next-line @typescript-eslint/camelcase
+    DIVE_Projects: {
+      projectid1: {
+        'meta.json': JSON.stringify({
+          version: 1,
+          id: 'projectid1',
+          type: 'image-sequence',
+          fps: 5,
+          originalBasePath: '/home/user/media/projectid1data',
+          originalImageFiles: [
+            'foo.png',
+            'bar.png',
+          ],
+        } as JsonMeta),
+        'result_whatever.json': JSON.stringify({}),
+        auxiliary: {},
+      },
+      projectid1VideoGood: {
+        'meta.json': JSON.stringify({
+          version: 1,
+          id: 'projectid1',
+          type: 'video',
+          fps: 5,
+          originalVideoFile: 'whatever.mp4',
+          transcodedVideoFile: 'whatever-transcoded.mp4',
+        } as JsonMeta),
+        'result_whatever.json': JSON.stringify({}),
+        auxiliary: {},
+      },
+      projectid2Bad: {
+        'meta.json': '{}',
+        // Won't match
+        'results_invalid.json': '',
+        auxiliary: {},
+      },
+      projectid3Bad: {},
+      projectid4Bad: {
+        'meta.json': '{}',
+        // Too many results
+        'result_1.json': '',
+        'result_2.json': '',
+        auxiliary: {},
+      },
+    },
+  },
+});
+
+describe('native.common', () => {
+  it('getPipelineList lists pipelines', async () => {
+    const exists = await fs.pathExists(settings.viamePath);
+    expect(exists).toBe(true);
+    const pipes = await common.getPipelineList(settings);
+    expect(pipes).toBeTruthy();
+    expect(pipes.detector.pipes).toHaveLength(4);
+    expect(pipes.tracker.pipes).toHaveLength(5);
+    expect(pipes.generate.pipes).toHaveLength(4);
+    expect(pipes.training).toBeUndefined();
+  });
+
+  it('getValidatedProjectDir loads correct project directory', async () => {
+    const basedir = 'DIVE_Projects/projectid1';
+    const dir = await common.getValidatedProjectDir(settings, 'projectid1');
+    expect(dir.basePath).toBe(npath.join(settings.dataPath, basedir));
+    expect(dir.metaFileAbsPath).toBe(npath.join(settings.dataPath, basedir, 'meta.json'));
+    expect(dir.auxDirAbsPath).toBe(npath.join(settings.dataPath, basedir, 'auxiliary'));
+    expect(dir.trackFileAbsPath).toBe(npath.join(settings.dataPath, basedir, 'result_whatever.json'));
+  });
+
+  it('getValidatedProjectDir fails to load project directory for invalid contents', async () => {
+    await expect(common.getValidatedProjectDir(settings, 'projectid2Bad'))
+      .rejects.toThrow('missing track json file');
+    await expect(common.getValidatedProjectDir(settings, 'projectid3Bad'))
+      .rejects.toThrow('missing metadata json file');
+    await expect(common.getValidatedProjectDir(settings, 'projectid4Bad'))
+      .rejects.toThrow('too many matches');
+  });
+
+  it('loadJsonMetadata loads metadata from file', async () => {
+    const data = await common.loadMetadata(settings, 'projectid1', urlMapper);
+    expect(data.id).toBe('projectid1');
+    expect(data.imageData.map(({ filename }) => filename)).toEqual([
+      'foo.png', 'bar.png',
+    ]);
+  });
+
+  it('loadJsonMetadata prefers transcoded media when it exists', async () => {
+    const data = await common.loadMetadata(settings, 'projectid1VideoGood', urlMapper);
+    const videoPath = npath.join(
+      settings.dataPath, 'DIVE_Projects', 'projectid1VideoGood', 'whatever-transcoded.mp4',
+    );
+    expect(data.videoUrl).toBe(`http://localhost:8888/api/media?path=${videoPath}`);
+  });
+
+  it('createKwiverRunWorkingDir creates pipeline run directories', async () => {
+    await expect(common.createKwiverRunWorkingDir(settings, [], 'whatever.pipe'))
+      .rejects.toThrow('At least 1 jsonMeta item');
+    const jsonMeta: JsonMeta = {
+      version: 1,
+      type: 'image-sequence',
+      fps: 100,
+      name: 'myproject1_name',
+      createdAt: (new Date()).toString(),
+      originalBasePath: '/foo/bar/baz',
+      id: 'myproject1',
+      originalImageFiles: [],
+      originalVideoFile: '',
+    };
+    const result = await common.createKwiverRunWorkingDir(settings, [jsonMeta], 'mypipeline.pipe');
+    const stat = fs.statSync(result);
+    const contents = fs.readdirSync(result);
+    expect(stat.isDirectory()).toBe(true);
+    expect(contents).toEqual([]);
+    expect(result).toMatch(/DIVE_Jobs\/myproject1_name_mypipeline\.pipe_/);
+  });
+
+  it('importMedia image sequence success', async () => {
+    const meta = await common.importMedia(settings, '/home/user/data/imageSuccess');
+    expect(meta.name).toBe('imageSuccess');
+    expect(meta.originalImageFiles.length).toBe(2);
+    expect(meta.originalVideoFile).toBe('');
+    expect(meta.originalBasePath).toBe('/home/user/data/imageSuccess');
+  });
+
+  it('importMedia video success', async () => {
+    const meta = await common.importMedia(settings, '/home/user/data/videoSuccess/video1.mp4');
+    expect(meta.name).toBe('video1');
+    expect(meta.originalImageFiles.length).toBe(0);
+    expect(meta.originalVideoFile).toBe('video1.mp4');
+    expect(meta.originalBasePath).toBe('/home/user/data/videoSuccess');
+  });
+
+  it('importMedia various failure modes', async () => {
+    await expect(common.importMedia(settings, '/fake/path'))
+      .rejects.toThrow('file or directory not found');
+    await expect(common.importMedia(settings, '/home/user/data/imageSuccess/foo.png'))
+      .rejects.toThrow('chose image file for video import option');
+    await expect(common.importMedia(settings, '/home/user/data/videoSuccess/otherfile.txt'))
+      .rejects.toThrow('unsupported MIME type');
+    await expect(common.importMedia(settings, '/home/user/data/videoSuccess/video1.avi'))
+      .rejects.toThrow('unsupported MIME type');
+    await expect(common.importMedia(settings, '/home/user/data/videoSuccess/nomime'))
+      .rejects.toThrow('could not determine video MIME');
+    await expect(common.importMedia(settings, '/home/user/data/annotationFail/video1.mp4'))
+      .rejects.toThrow('too many CSV');
+  });
+});
+
+afterAll(() => {
+  mockfs.restore();
+});
diff --git a/client/platform/desktop/backend/native/common.ts b/client/platform/desktop/backend/native/common.ts
new file mode 100644
index 000000000..91d32d649
--- /dev/null
+++ b/client/platform/desktop/backend/native/common.ts
@@ -0,0 +1,482 @@
+/**
+ * Common native implementations
+ */
+import npath from 'path';
+import fs from 'fs-extra';
+import { shell } from 'electron';
+import mime from 'mime-types';
+import moment from 'moment';
+import {
+  DatasetType, MultiTrackRecord, Pipelines, SaveDetectionsArgs, FrameImage, DatasetMetaMutable,
+} from 'viame-web-common/apispec';
+
+import {
+  websafeImageTypes, websafeVideoTypes, otherImageTypes,
+  JsonMeta, Settings, JsonMetaCurrentVersion, DesktopMetadata,
+} from 'platform/desktop/constants';
+import * as viameSerializers from 'platform/desktop/backend/serializers/viame';
+
+import { cleanString, makeid } from './utils';
+
+const ProjectsFolderName = 'DIVE_Projects';
+const JobsFolderName = 'DIVE_Jobs';
+const AuxFolderName = 'auxiliary';
+
+const JsonTrackFileName = /^result(_.*)?\.json$/;
+const JsonMetaFileName = 'meta.json';
+const CsvFileName = /^.*\.csv$/;
+
+/**
+ * locate json track file in a directory
+ * @param path path to a directory
+ * @returns absolute path to json file or null
+ */
+async function _findJsonTrackFile(basePath: string): Promise<string | null> {
+  const contents = await fs.readdir(basePath);
+  const jsonFileCandidates: string[] = [];
+  await Promise.all(contents.map(async (name) => {
+    if (JsonTrackFileName.test(name)) {
+      const fullPath = npath.join(basePath, name);
+      const statResult = await fs.stat(fullPath);
+      if (statResult.isFile()) {
+        jsonFileCandidates.push(fullPath);
+      }
+    }
+  }));
+  if (jsonFileCandidates.length > 1) {
+    throw new Error(`too many matches for json annotation file in ${basePath}.  cannot determine correct choice.  please verify only 1 json annotation file exists.`);
+  } else if (jsonFileCandidates.length === 1) {
+    return jsonFileCandidates[0];
+  }
+  return null;
+}
+
+/**
+ * getProjectDir returns filepaths to required members of a dataset project directory.
+ */
+function getProjectDir(settings: Settings, datasetId: string) {
+  const basePath = npath.join(settings.dataPath, ProjectsFolderName, datasetId);
+  const auxDirAbsPath = npath.join(basePath, AuxFolderName);
+  const metaFileAbsPath = npath.join(basePath, JsonMetaFileName);
+  return {
+    auxDirAbsPath,
+    basePath,
+    metaFileAbsPath,
+  };
+}
+
+/**
+ * REQUIRED members: meta.json, results*.json
+ * OPTIONAL members: aux/ will be created if none exists
+ */
+async function getValidatedProjectDir(settings: Settings, datasetId: string) {
+  const projectInfo = getProjectDir(settings, datasetId);
+  fs.ensureDirSync(projectInfo.auxDirAbsPath);
+  if (!fs.pathExistsSync(projectInfo.basePath)) {
+    throw new Error(`missing project directory ${projectInfo.basePath}`);
+  }
+  if (!fs.pathExistsSync(projectInfo.metaFileAbsPath)) {
+    throw new Error(`missing metadata json file ${projectInfo.metaFileAbsPath}`);
+  }
+  const trackFileAbsPath = await _findJsonTrackFile(projectInfo.basePath);
+  if (trackFileAbsPath === null) {
+    throw new Error(`missing track json file in ${projectInfo.basePath}`);
+  }
+  return {
+    ...projectInfo,
+    trackFileAbsPath,
+  };
+}
+
+/**
+ * loadJsonMeta processes dataset information from json
+ * @param metaPath a known, existing path
+ */
+async function loadJsonMetadata(metaAbsPath: string): Promise<JsonMeta> {
+  const rawBuffer = await fs.readFile(metaAbsPath, 'utf-8');
+  const metaJson = JSON.parse(rawBuffer);
+  /* check if this file meets the current schema version */
+  if ('version' in metaJson) {
+    const { version } = metaJson;
+    if (version !== JsonMetaCurrentVersion) {
+      // TODO: schema migration for older schema versions
+      throw new Error('outdated meta schema version found, migration not implemented');
+    }
+  }
+  return metaJson as JsonMeta;
+}
+
+/**
+ * _loadJsonTracks load from file
+ * @param tracksPath a known, existing path
+ */
+async function _loadJsonTracks(tracksAbsPath: string): Promise<MultiTrackRecord> {
+  const rawBuffer = await fs.readFile(tracksAbsPath, 'utf-8');
+  const annotationData = JSON.parse(rawBuffer) as MultiTrackRecord;
+  // TODO: somehow verify the schema of this file
+  if (Array.isArray(annotationData)) {
+    throw new Error('object expected in track json');
+  }
+  return annotationData;
+}
+
+async function loadMetadata(
+  settings: Settings,
+  datasetId: string,
+  makeMediaUrl: (path: string) => string,
+): Promise<DesktopMetadata> {
+  const projectDirData = await getValidatedProjectDir(settings, datasetId);
+  const projectMetaData = await loadJsonMetadata(projectDirData.metaFileAbsPath);
+
+  let videoUrl = '';
+  let imageData = [] as FrameImage[];
+
+  /* Generate URLs against embedded media server from known file paths on disk */
+  if (projectMetaData.type === 'video') {
+    /* If the video has been transcoded, use that video */
+    if (projectMetaData.transcodedVideoFile) {
+      const video = npath.join(projectDirData.basePath, projectMetaData.transcodedVideoFile);
+      videoUrl = makeMediaUrl(video);
+    } else {
+      const video = npath.join(projectMetaData.originalBasePath, projectMetaData.originalVideoFile);
+      videoUrl = makeMediaUrl(video);
+    }
+  } else if (projectMetaData.type === 'image-sequence') {
+    /* TODO: if images were transcoded, use them */
+    imageData = projectMetaData.originalImageFiles.map((filename: string) => ({
+      url: makeMediaUrl(npath.join(projectMetaData.originalBasePath, filename)),
+      filename,
+    }));
+  } else {
+    throw new Error(`unexpected project type for id="${datasetId}" type="${projectMetaData.type}"`);
+  }
+
+  return {
+    ...projectMetaData,
+    videoUrl,
+    imageData,
+  };
+}
+
+async function loadDetections(settings: Settings, datasetId: string) {
+  const projectDirData = await getValidatedProjectDir(settings, datasetId);
+  return _loadJsonTracks(projectDirData.trackFileAbsPath);
+}
+
+/**
+ * Get all runnable pipelines
+ * @param settings app settings
+ */
+async function getPipelineList(settings: Settings): Promise<Pipelines> {
+  const pipelinePath = npath.join(settings.viamePath, 'configs/pipelines');
+  const allowedPatterns = /^detector_.+|^tracker_.+|^generate_.+/;
+  const disallowedPatterns = /.*local.*|detector_svm_models.pipe|tracker_svm_models.pipe/;
+  const exists = await fs.pathExists(pipelinePath);
+  if (!exists) return {};
+  let pipes = await fs.readdir(pipelinePath);
+  pipes = pipes.filter((p) => p.match(allowedPatterns) && !p.match(disallowedPatterns));
+
+  /* TODO: fetch trained pipelines */
+  const ret: Pipelines = {};
+  pipes.forEach((p) => {
+    const parts = p.replace('.pipe', '').split('_');
+    const pipeType = parts[0];
+    const pipeName = parts.slice(1).join(' ');
+    const pipeInfo = {
+      name: pipeName,
+      type: pipeType,
+      pipe: p,
+    };
+    if (pipeType in ret) {
+      ret[pipeType].pipes.push(pipeInfo);
+    } else {
+      ret[pipeType] = {
+        pipes: [pipeInfo],
+        description: '',
+      };
+    }
+  });
+  return ret;
+}
+
+/**
+ * Create `job_runs/{runfoldername}` folder, usually inside an aux folder
+ * @param baseDir parent
+ * @param pipeline name
+ */
+async function createKwiverRunWorkingDir(
+  settings: Settings, jsonMetaList: JsonMeta[], pipeline: string,
+) {
+  if (jsonMetaList.length === 0) {
+    throw new Error('At least 1 jsonMeta item must be provided');
+  }
+  const jobFolderPath = npath.join(settings.dataPath, JobsFolderName);
+  // eslint won't recognize \. as valid escape
+  // eslint-disable-next-line no-useless-escape
+  const safeDatasetName = jsonMetaList[0].name.replace(/[\.\s/]+/g, '_');
+  const runFolderName = moment().format(`[${safeDatasetName}_${pipeline}]_MM-DD-yy_hh-mm-ss`);
+  const runFolderPath = npath.join(jobFolderPath, runFolderName);
+  if (!fs.existsSync(jobFolderPath)) {
+    await fs.mkdir(jobFolderPath);
+  }
+  await fs.mkdir(runFolderPath);
+  return runFolderPath;
+}
+
+/**
+ * _saveSerialized save pre-serialized tracks to disk
+ */
+async function _saveSerialized(
+  settings: Settings,
+  datasetId: string,
+  trackData: MultiTrackRecord,
+) {
+  const time = moment().format('MM-DD-YYYY_hh-mm-ss');
+  const newFileName = `result_${time}.json`;
+  const projectInfo = getProjectDir(settings, datasetId);
+
+  try {
+    const validatedInfo = await getValidatedProjectDir(settings, datasetId);
+    await fs.move(
+      validatedInfo.trackFileAbsPath,
+      npath.join(
+        validatedInfo.auxDirAbsPath,
+        npath.basename(validatedInfo.trackFileAbsPath),
+      ),
+    );
+  } catch (err) {
+    // Some part of the project dir didn't exist
+  }
+  const serialized = JSON.stringify(trackData);
+  await fs.writeFile(npath.join(projectInfo.basePath, newFileName), serialized);
+}
+
+/**
+ * Save detections to json file in aux
+ */
+async function saveDetections(settings: Settings, datasetId: string, args: SaveDetectionsArgs) {
+  /* Update existing track file */
+  const projectDirInfo = await getValidatedProjectDir(settings, datasetId);
+  const existing = await _loadJsonTracks(projectDirInfo.trackFileAbsPath);
+  args.delete.forEach((trackId) => delete existing[trackId.toString()]);
+  args.upsert.forEach((track) => {
+    existing[track.trackId.toString()] = track;
+  });
+  return _saveSerialized(settings, datasetId, existing);
+}
+
+/**
+ * _saveAsJson saves directly to disk
+ */
+async function _saveAsJson(absPath: string, data: unknown) {
+  const serialized = JSON.stringify(data, null, 2);
+  await fs.writeFile(absPath, serialized);
+}
+
+async function saveMetadata(settings: Settings, datasetId: string, args: DatasetMetaMutable) {
+  const projectDirInfo = await getValidatedProjectDir(settings, datasetId);
+  const existing = await loadJsonMetadata(projectDirInfo.metaFileAbsPath);
+  if (args.confidenceFilters) {
+    existing.confidenceFilters = args.confidenceFilters;
+  }
+  if (args.customTypeStyling) {
+    existing.customTypeStyling = args.customTypeStyling;
+  }
+  _saveAsJson(projectDirInfo.metaFileAbsPath, existing);
+}
+
+/**
+ * processOtherAnnotationFiles imports data from external annotation formats
+ * given a list of candidate file paths.
+ *
+ * SUPPORTED FORMATS:
+ * VIAME CSV
+ *
+ * @param paths paths to possible input annotation files
+ * @param datasetId dataset id path
+ */
+async function processOtherAnnotationFiles(
+  settings: Settings,
+  datasetId: string,
+  absPaths: string[],
+): Promise<{ fps?: number; processedFiles: string[] }> {
+  const fps = undefined;
+  const processedFiles = []; // which files were processed to generate the detections
+
+  for (let i = 0; i < absPaths.length; i += 1) {
+    const path = absPaths[i];
+    if (!fs.existsSync(path)) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    if (fs.statSync(path).size > 0) {
+      // Attempt to process the file
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const tracks = await viameSerializers.parseFile(path);
+        const data: MultiTrackRecord = {};
+        tracks.forEach((t) => { data[t.trackId.toString()] = t; });
+        // eslint-disable-next-line no-await-in-loop
+        await _saveSerialized(settings, datasetId, data);
+        processedFiles.push(path);
+        break; // Exit on first successful detection load
+      } catch (err) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+    }
+  }
+  return { fps, processedFiles };
+}
+
+async function _initializeAppDataDir(settings: Settings) {
+  await fs.ensureDir(settings.dataPath);
+  await fs.ensureDir(npath.join(settings.dataPath, ProjectsFolderName));
+  await fs.ensureDir(npath.join(settings.dataPath, JobsFolderName));
+}
+
+/**
+ * Intialize a new project directory
+ * @returns absolute path to new project dcirectory
+ */
+async function _initializeProjectDir(settings: Settings, jsonMeta: JsonMeta): Promise<string> {
+  const projectDir = npath.join(settings.dataPath, ProjectsFolderName, jsonMeta.id);
+  await _initializeAppDataDir(settings);
+  await fs.ensureDir(projectDir);
+  return projectDir;
+}
+
+/**
+ * importMedia locates as much information as possible
+ * about a dataset using only the directory structure.
+ * @param settings user settings
+ * @param path path to import dir/file
+ * @returns datasetId
+ */
+async function importMedia(settings: Settings, path: string): Promise<JsonMeta> {
+  let datasetType: DatasetType;
+
+  const exists = fs.existsSync(path);
+  if (!exists) {
+    throw new Error(`file or directory not found: ${path}`);
+  }
+
+  const stat = await fs.stat(path);
+  if (stat.isDirectory()) {
+    datasetType = 'image-sequence';
+  } else if (stat.isFile()) {
+    datasetType = 'video';
+  } else {
+    throw new Error('Only regular files and directories are supported');
+  }
+
+  const dsName = npath.parse(path).name;
+  const dsId = `${cleanString(dsName).substr(0, 20)}_${makeid(10)}`;
+
+  const jsonMeta: JsonMeta = {
+    version: JsonMetaCurrentVersion,
+    type: datasetType,
+    id: dsId,
+    fps: 5, // TODO
+    originalBasePath: path,
+    originalVideoFile: '',
+    createdAt: (new Date()).toString(),
+    originalImageFiles: [],
+    transcodedVideoFile: '', // TODO: this is empty (see above)
+    transcodedImageFiles: [], // TODO: this is empty
+    name: dsName,
+  };
+
+  /* TODO: Look for an EXISTING meta.json file to override the above */
+
+  if (datasetType === 'video') {
+    // get parent folder, since videos reference a file directly
+    jsonMeta.originalBasePath = npath.dirname(path);
+  }
+
+  const contents = await fs.readdir(jsonMeta.originalBasePath);
+
+  /* Extract and validate media from import path */
+  if (jsonMeta.type === 'video') {
+    jsonMeta.originalVideoFile = npath.basename(path);
+    const mimetype = mime.lookup(path);
+    if (mimetype) {
+      if (websafeImageTypes.includes(mimetype) || otherImageTypes.includes(mimetype)) {
+        throw new Error('User chose image file for video import option');
+      } else if (websafeVideoTypes.includes(mimetype)) {
+        /* TODO: Kick off video inspection and maybe transcode */
+      } else {
+        throw new Error(`unsupported MIME type for video ${mimetype}`);
+      }
+    } else {
+      throw new Error(`could not determine video MIME type for ${path}`);
+    }
+  } else if (datasetType === 'image-sequence') {
+    jsonMeta.originalImageFiles = contents.filter((filename) => {
+      const abspath = npath.join(jsonMeta.originalBasePath, filename);
+      const mimetype = mime.lookup(abspath);
+      /* TODO: support transcoding of non-web-safe image types */
+      return !!(mimetype && websafeImageTypes.includes(mimetype));
+    });
+    if (jsonMeta.originalImageFiles.length === 0) {
+      throw new Error(`no images found in ${path}`);
+    }
+  } else {
+    throw new Error('only video and image-sequence types are supported');
+  }
+
+  const projectDirAbsPath = await _initializeProjectDir(settings, jsonMeta);
+  await _saveAsJson(npath.join(projectDirAbsPath, JsonMetaFileName), jsonMeta);
+
+  let foundDetections = false;
+
+  /* Look for JSON track file as first priority */
+  const trackFileAbsPath = await _findJsonTrackFile(jsonMeta.originalBasePath);
+  if (trackFileAbsPath !== null) {
+    /* Move the track file into the new project directory */
+    await fs.copy(
+      trackFileAbsPath,
+      npath.join(projectDirAbsPath, npath.basename(trackFileAbsPath)),
+    );
+    foundDetections = true;
+  }
+  /* Look for other types of annotation files as a second priority */
+  if (!foundDetections) {
+    const csvFileCandidates = contents
+      .filter((v) => CsvFileName.test(v))
+      .map((filename) => npath.join(jsonMeta.originalBasePath, filename));
+    if (csvFileCandidates.length > 1) {
+      throw new Error(`too many CSV files found in ${jsonMeta.originalBasePath}, expected at most 1`);
+    }
+    const { fps, processedFiles } = await processOtherAnnotationFiles(
+      settings, dsId, csvFileCandidates,
+    );
+    if (fps) jsonMeta.fps = fps;
+    foundDetections = processedFiles.length > 0;
+  }
+  /* Finally create an empty file as fallback */
+  if (!foundDetections) {
+    await _saveSerialized(settings, dsId, {});
+  }
+
+  return jsonMeta;
+}
+
+async function openLink(url: string) {
+  shell.openExternal(url);
+}
+
+export default {
+  createKwiverRunWorkingDir,
+  getPipelineList,
+  getProjectDir,
+  getValidatedProjectDir,
+  importMedia,
+  loadMetadata,
+  loadJsonMetadata,
+  loadDetections,
+  openLink,
+  processOtherAnnotationFiles,
+  saveDetections,
+  saveMetadata,
+};
diff --git a/client/platform/desktop/backend/platforms/linux.ts b/client/platform/desktop/backend/native/linux.ts
similarity index 84%
rename from client/platform/desktop/backend/platforms/linux.ts
rename to client/platform/desktop/backend/native/linux.ts
index b10875883..193b115b9 100644
--- a/client/platform/desktop/backend/platforms/linux.ts
+++ b/client/platform/desktop/backend/native/linux.ts
@@ -1,6 +1,7 @@
 /**
  * VIAME process manager for linux platform
  */
+import os from 'os';
 import npath from 'path';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
@@ -10,7 +11,7 @@ import {
   Settings, SettingsCurrentVersion,
   DesktopJob, DesktopJobUpdate, RunPipeline,
   NvidiaSmiReply,
-} from '../../constants';
+} from 'platform/desktop/constants';
 
 import common from './common';
 
@@ -20,7 +21,7 @@ const DefaultSettings: Settings = {
   // A path to the VIAME base install
   viamePath: '/opt/noaa/viame',
   // Path to a user data folder
-  dataPath: '~/viamedata',
+  dataPath: npath.join(os.homedir(), 'VIAME_DATA'),
 };
 
 async function validateViamePath(settings: Settings): Promise<true | string> {
@@ -53,45 +54,45 @@ async function validateViamePath(settings: Settings): Promise<true | string> {
  * @param settings global settings
  */
 async function runPipeline(
+  settings: Settings,
   runPipelineArgs: RunPipeline,
   updater: (msg: DesktopJobUpdate) => void,
 ): Promise<DesktopJob> {
-  const { settings, datasetId, pipelineName } = runPipelineArgs;
+  const { datasetId, pipeline } = runPipelineArgs;
   const isValid = await validateViamePath(settings);
   if (isValid !== true) {
     throw new Error(isValid);
   }
 
   const setupScriptPath = npath.join(settings.viamePath, 'setup_viame.sh');
-  const pipelinePath = npath.join(settings.viamePath, 'configs/pipelines', pipelineName);
-  const datasetInfo = await common.getDatasetBase(datasetId);
-  const auxPath = await common.getAuxFolder(datasetInfo.basePath);
-  const jobWorkDir = await common.createKwiverRunWorkingDir(
-    datasetInfo.name, auxPath, pipelineName,
-  );
+  const pipelinePath = npath.join(settings.viamePath, 'configs/pipelines', pipeline.pipe);
+  const projectInfo = await common.getValidatedProjectDir(settings, datasetId);
+  const meta = await common.loadJsonMetadata(projectInfo.metaFileAbsPath);
+  const jobWorkDir = await common.createKwiverRunWorkingDir(settings, [meta], pipeline.name);
 
   const detectorOutput = npath.join(jobWorkDir, 'detector_output.csv');
   const trackOutput = npath.join(jobWorkDir, 'track_output.csv');
   const joblog = npath.join(jobWorkDir, 'runlog.txt');
 
   let command: string[] = [];
-  if (datasetInfo.datasetType === 'video') {
+  if (meta.type === 'video') {
+    const videoAbsPath = npath.join(meta.originalBasePath, meta.originalVideoFile);
     command = [
       `source ${setupScriptPath} &&`,
       'kwiver runner',
       '-s input:video_reader:type=vidl_ffmpeg',
       `-p ${pipelinePath}`,
-      `-s input:video_filename=${datasetId}`,
+      `-s input:video_filename=${videoAbsPath}`,
       `-s detector_writer:file_name=${detectorOutput}`,
       `-s track_writer:file_name=${trackOutput}`,
       `| tee ${joblog}`,
     ];
-  } else if (datasetInfo.datasetType === 'image-sequence') {
+  } else if (meta.type === 'image-sequence') {
     // Create frame image manifest
     const manifestFile = npath.join(jobWorkDir, 'image-manifest.txt');
     // map image file names to absolute paths
-    const fileData = datasetInfo.imageFiles
-      .map((f) => npath.join(datasetInfo.basePath, f))
+    const fileData = meta.originalImageFiles
+      .map((f) => npath.join(meta.originalBasePath, f))
       .join('\n');
     await fs.writeFile(manifestFile, fileData);
     command = [
@@ -114,7 +115,7 @@ async function runPipeline(
     key: `pipeline_${job.pid}_${jobWorkDir}`,
     jobType: 'pipeline',
     pid: job.pid,
-    pipelineName,
+    pipeline,
     workingDir: jobWorkDir,
     datasetIds: [datasetId],
     exitCode: job.exitCode,
@@ -148,7 +149,9 @@ async function runPipeline(
     // eslint-disable-next-line no-console
     if (code === 0) {
       try {
-        await common.postprocess([trackOutput, detectorOutput], datasetId);
+        await common.processOtherAnnotationFiles(
+          settings, datasetId, [trackOutput, detectorOutput],
+        );
       } catch (err) {
         console.error(err);
       }
diff --git a/client/platform/desktop/backend/native/utils.ts b/client/platform/desktop/backend/native/utils.ts
new file mode 100644
index 000000000..22de84347
--- /dev/null
+++ b/client/platform/desktop/backend/native/utils.ts
@@ -0,0 +1,24 @@
+
+/**
+ * Get a nice safe string
+ */
+function cleanString(dirty: string) {
+  return dirty.replace(/[^a-z0-9]/gi, '_').toLowerCase();
+}
+
+// https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript
+function makeid(length: number): string {
+  let result = '';
+  const characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  const charactersLength = characters.length;
+  for (let i = 0; i < length; i += 1) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+
+// eslint-disable-next-line import/prefer-default-export
+export {
+  cleanString,
+  makeid,
+};
diff --git a/client/platform/desktop/backend/platforms/windows.ts b/client/platform/desktop/backend/native/windows.ts
similarity index 90%
rename from client/platform/desktop/backend/platforms/windows.ts
rename to client/platform/desktop/backend/native/windows.ts
index 9979a65cc..348fca78a 100644
--- a/client/platform/desktop/backend/platforms/windows.ts
+++ b/client/platform/desktop/backend/native/windows.ts
@@ -11,7 +11,7 @@ import {
   Settings, SettingsCurrentVersion,
   DesktopJob, DesktopJobUpdate, RunPipeline,
   NvidiaSmiReply,
-} from '../../constants';
+} from 'platform/desktop/constants';
 
 import common from './common';
 
@@ -68,21 +68,22 @@ async function validateViamePath(settings: Settings): Promise<true | string> {
  * @param settings global settings
  */
 async function runPipeline(
+  settings: Settings,
   runPipelineArgs: RunPipeline,
   updater: (msg: DesktopJobUpdate) => void,
 ): Promise<DesktopJob> {
-  const { settings, datasetId, pipelineName } = runPipelineArgs;
+  const { datasetId, pipeline } = runPipelineArgs;
   const isValid = await validateViamePath(settings);
   if (isValid !== true) {
     throw new Error(isValid);
   }
 
   const setupScriptPath = npath.join(settings.viamePath, 'setup_viame.bat');
-  const pipelinePath = npath.join(settings.viamePath, 'configs/pipelines', pipelineName);
-  const datasetInfo = await common.getDatasetBase(datasetId);
-  const auxPath = await common.getAuxFolder(datasetInfo.basePath);
+  const pipelinePath = npath.join(settings.viamePath, 'configs/pipelines', pipeline.pipe);
+  const projectInfo = await common.getValidatedProjectDir(settings, datasetId);
+  const meta = await common.loadJsonMetadata(projectInfo.metaFileAbsPath);
   const jobWorkDir = await common.createKwiverRunWorkingDir(
-    datasetInfo.name, auxPath, pipelineName,
+    settings, [meta], pipeline.name,
   );
 
   const detectorOutput = npath.join(jobWorkDir, 'detector_output.csv');
@@ -92,7 +93,7 @@ async function runPipeline(
   const modifiedCommand = `"${setupScriptPath.replace(/\\/g, '\\')}"`;
 
   let command: string[] = [];
-  if (datasetInfo.datasetType === 'video') {
+  if (meta.type === 'video') {
     command = [
       `${modifiedCommand} &&`,
       'kwiver.exe runner',
@@ -102,12 +103,12 @@ async function runPipeline(
       `-s detector_writer:file_name=${detectorOutput}`,
       `-s track_writer:file_name=${trackOutput}`,
     ];
-  } else if (datasetInfo.datasetType === 'image-sequence') {
+  } else if (meta.type === 'image-sequence') {
     // Create frame image manifest
     const manifestFile = npath.join(jobWorkDir, 'image-manifest.txt');
     // map image file names to absolute paths
-    const fileData = datasetInfo.imageFiles
-      .map((f) => npath.join(datasetInfo.basePath, f))
+    const fileData = meta.originalImageFiles
+      .map((f) => npath.join(projectInfo.basePath, f))
       .join('\n');
     await fs.writeFile(manifestFile, fileData);
     command = [
@@ -129,7 +130,7 @@ async function runPipeline(
     key: `pipeline_${job.pid}_${jobWorkDir}`,
     jobType: 'pipeline',
     pid: job.pid,
-    pipelineName,
+    pipeline,
     workingDir: jobWorkDir,
     datasetIds: [datasetId],
     exitCode: job.exitCode,
@@ -169,7 +170,9 @@ async function runPipeline(
   job.on('exit', async (code) => {
     if (code === 0) {
       try {
-        await common.postprocess([trackOutput, detectorOutput], datasetId);
+        await common.processOtherAnnotationFiles(
+          settings, datasetId, [trackOutput, detectorOutput],
+        );
       } catch (err) {
         console.error(err);
       }
@@ -185,9 +188,7 @@ async function runPipeline(
   return jobBase;
 }
 
-function checkDefaultNvidiaSmi(
-  resolve: (value?: NvidiaSmiReply | PromiseLike<NvidiaSmiReply> | undefined) => void,
-) {
+function checkDefaultNvidiaSmi(resolve: (value: NvidiaSmiReply) => void) {
   const smi = spawn(`"${programFiles}\\NVIDIA Corporation\\NVSMI\\nvidia-smi.exe"`, ['-q', '-x'], { shell: true });
   let result = '';
   smi.stdout.on('data', (chunk) => {
@@ -243,6 +244,7 @@ async function nvidiaSmi(): Promise<NvidiaSmiReply> {
     });
   });
 }
+
 export default {
   DefaultSettings,
   validateViamePath,
diff --git a/client/platform/desktop/backend/platforms/common.ts b/client/platform/desktop/backend/platforms/common.ts
deleted file mode 100644
index 80d03f3f3..000000000
--- a/client/platform/desktop/backend/platforms/common.ts
+++ /dev/null
@@ -1,287 +0,0 @@
-/**
- * Common native implementations
- */
-import npath from 'path';
-import fs from 'fs-extra';
-import { shell } from 'electron';
-import mime from 'mime-types';
-import moment from 'moment';
-import { TrackData } from 'vue-media-annotator/track';
-import { DatasetType, Pipelines, SaveDetectionsArgs } from 'viame-web-common/apispec';
-
-import { Settings, websafeImageTypes } from '../../constants';
-import * as viameSerializers from '../serializers/viame';
-
-const AuxFolderName = 'auxiliary';
-const JobFolderName = 'job_runs';
-// Match examples:
-// result_09-14-2020_14-49-05.json
-// result_<ANYTHING>.json
-// result.json
-const JsonFileName = /^result(_.*)?\.json$/;
-const CsvFileName = /^.*\.csv$/;
-
-async function getDatasetBase(datasetId: string): Promise<{
-  datasetType: DatasetType;
-  basePath: string;
-  name: string;
-  jsonFile: string | null;
-  imageFiles: string[];
-  directoryContents: string[];
-}> {
-  let datasetType: DatasetType = 'image-sequence';
-  const exists = fs.existsSync(datasetId);
-  if (!exists) {
-    throw new Error(`No dataset exists with path ${datasetId}`);
-  }
-  const stat = await fs.stat(datasetId);
-
-  if (stat.isDirectory()) {
-    datasetType = 'image-sequence';
-  } else if (stat.isFile()) {
-    datasetType = 'video';
-  } else {
-    throw new Error('Only regular files and directories are supported');
-  }
-
-  let datasetFolderPath = datasetId;
-  if (datasetType === 'video') {
-    // get parent folder, since videos reference a file directly
-    datasetFolderPath = npath.dirname(datasetId);
-  }
-
-  const contents = await fs.readdir(datasetFolderPath);
-
-  const imageFiles = contents.filter((filename) => {
-    const abspath = npath.join(datasetFolderPath, filename);
-    const mimetype = mime.lookup(abspath);
-    if (mimetype && websafeImageTypes.includes(mimetype)) {
-      return true;
-    }
-    return false;
-  });
-
-  const jsonFileCandidates: string[] = [];
-  await Promise.all(contents.map(async (name) => {
-    if (JsonFileName.test(name)) {
-      const fullPath = npath.join(datasetFolderPath, name);
-      const statResult = await fs.stat(fullPath);
-      if (statResult.isFile()) {
-        jsonFileCandidates.push(name);
-      }
-    }
-  }));
-
-  let jsonFile = null;
-  if (jsonFileCandidates.length > 1) {
-    throw new Error('Too many matches for json annotation file!');
-  } else if (jsonFileCandidates.length === 1) {
-    [jsonFile] = jsonFileCandidates;
-  }
-
-  return {
-    datasetType,
-    basePath: datasetFolderPath,
-    jsonFile,
-    imageFiles,
-    name: npath.parse(datasetId).name,
-    directoryContents: contents,
-  };
-}
-
-/**
- * Load annotations from JSON
- * @param path a known, existing path
- */
-async function loadJsonAnnotations(path: string): Promise<Record<string, TrackData>> {
-  const rawBuffer = await fs.readFile(path, 'utf-8');
-  const annotationData = JSON.parse(rawBuffer);
-  // TODO: validate json schema
-  return annotationData as Record<string, TrackData>;
-}
-
-/**
- * Load detections from disk in priority order
- * @param datasetId path
- * @param ignoreCSV ignore CSV files if found
- */
-async function loadDetections(datasetId: string, ignoreCSV = false):
-  Promise<{ [key: string]: TrackData }> {
-  const data = {} as { [key: string]: TrackData };
-  const base = await getDatasetBase(datasetId);
-
-  /* First, look for a JSON file */
-  if (base.jsonFile) {
-    const annotations = loadJsonAnnotations(npath.join(base.basePath, base.jsonFile));
-    return annotations;
-  }
-
-  if (ignoreCSV) {
-    return Promise.resolve(data);
-  }
-
-  /* Then, look for a CSV */
-  const csvFileCandidates = base.directoryContents.filter((v) => CsvFileName.test(v));
-  if (csvFileCandidates.length === 1) {
-    const tracks = await viameSerializers.parseFile(
-      npath.join(base.basePath, csvFileCandidates[0]),
-    );
-    tracks.forEach((t) => { data[t.trackId.toString()] = t; });
-    return data;
-  }
-
-  /* return empty by default */
-  return Promise.resolve(data);
-}
-
-/**
- * Get all runnable pipelines
- * @param settings app settings
- */
-async function getPipelineList(settings: Settings): Promise<Pipelines> {
-  const pipelinePath = npath.join(settings.viamePath, 'configs/pipelines');
-  const allowedPatterns = /^detector_.+|^tracker_.+|^generate_.+/;
-  const disallowedPatterns = /.*local.*|detector_svm_models.pipe|tracker_svm_models.pipe/;
-  const exists = await fs.pathExists(pipelinePath);
-  if (!exists) return {};
-  let pipes = await fs.readdir(pipelinePath);
-  pipes = pipes.filter((p) => p.match(allowedPatterns) && !p.match(disallowedPatterns));
-
-  /* TODO: fetch trained pipelines */
-  const ret: Pipelines = {};
-  pipes.forEach((p) => {
-    const parts = p.replace('.pipe', '').split('_');
-    const pipeType = parts[0];
-    const pipeName = parts.slice(1).join(' ');
-    const pipeInfo = {
-      name: pipeName,
-      type: pipeType,
-      pipe: p,
-    };
-    if (pipeType in ret) {
-      ret[pipeType].pipes.push(pipeInfo);
-    } else {
-      ret[pipeType] = {
-        pipes: [pipeInfo],
-        description: '',
-      };
-    }
-  });
-  return ret;
-}
-
-/**
- * Create aux directory if none exists
- * @param baseDir parent
- */
-async function getAuxFolder(baseDir: string): Promise<string> {
-  const auxFolderPath = npath.join(baseDir, AuxFolderName);
-  if (!fs.existsSync(auxFolderPath)) {
-    await fs.mkdir(auxFolderPath);
-  }
-  return auxFolderPath;
-}
-
-/**
- * Create `job_runs/{runfoldername}` folder, usually inside an aux folder
- * @param baseDir parent
- * @param pipeline name
- */
-async function createKwiverRunWorkingDir(datasetName: string, baseDir: string, pipeline: string) {
-  const jobFolderPath = npath.join(baseDir, JobFolderName);
-  // eslint won't recognize \. as valid escape
-  // eslint-disable-next-line no-useless-escape
-  const safeDatasetName = datasetName.replace(/[\.\s/]+/g, '_');
-  const runFolderName = moment().format(`[${safeDatasetName}_${pipeline}]_MM-DD-yy_hh-mm-ss`);
-  const runFolderPath = npath.join(jobFolderPath, runFolderName);
-  if (!fs.existsSync(jobFolderPath)) {
-    await fs.mkdir(jobFolderPath);
-  }
-  await fs.mkdir(runFolderPath);
-  return runFolderPath;
-}
-
-/**
- * Save pre-serialized tracks to disk
- * @param datasetId path
- * @param trackData json serialized track object
- */
-async function saveSerialized(
-  datasetId: string,
-  trackData: Record<string, TrackData>,
-) {
-  const time = moment().format('MM-DD-YYYY_HH-MM-SS');
-  const newFileName = `result_${time}.json`;
-  const base = await getDatasetBase(datasetId);
-
-  const auxFolderPath = await getAuxFolder(base.basePath);
-
-  /* Move old file if it exists */
-  if (base.jsonFile) {
-    await fs.move(
-      npath.join(base.basePath, base.jsonFile),
-      npath.join(auxFolderPath, base.jsonFile),
-    );
-  }
-
-  const serialized = JSON.stringify(trackData);
-
-  /* Save new file */
-  await fs.writeFile(npath.join(base.basePath, newFileName), serialized);
-}
-
-/**
- * Save detections to json file in aux
- * @param datasetId path
- * @param args save args
- */
-async function saveDetections(datasetId: string, args: SaveDetectionsArgs) {
-  /* Update existing track file */
-  const existing = await loadDetections(datasetId, true);
-  args.delete.forEach((trackId) => delete existing[trackId.toString()]);
-  args.upsert.forEach((track, trackId) => {
-    existing[trackId.toString()] = track.serialize();
-  });
-  return saveSerialized(datasetId, existing);
-}
-
-/**
- * Postprocess possible annotation files
- * @param paths paths to input annotation files in descending priority order.
- *              Only the first successful input will be loaded.
- * @param datasetId dataset id path
- */
-async function postprocess(paths: string[], datasetId: string) {
-  for (let i = 0; i < paths.length; i += 1) {
-    const path = paths[i];
-    if (!fs.existsSync(path)) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    if (fs.statSync(path).size > 0) {
-      // Attempt to process the file
-      // eslint-disable-next-line no-await-in-loop
-      const tracks = await viameSerializers.parseFile(path);
-      const data = {} as Record<string, TrackData>;
-      tracks.forEach((t) => { data[t.trackId.toString()] = t; });
-      // eslint-disable-next-line no-await-in-loop
-      await saveSerialized(datasetId, data);
-      break; // Exit on first successful detection load
-    }
-  }
-}
-
-async function openLink(url: string) {
-  shell.openExternal(url);
-}
-
-export default {
-  openLink,
-  getAuxFolder,
-  createKwiverRunWorkingDir,
-  getDatasetBase,
-  getPipelineList,
-  loadDetections,
-  saveDetections,
-  postprocess,
-};
diff --git a/client/platform/desktop/backend/router.ts b/client/platform/desktop/backend/router.ts
deleted file mode 100644
index 831f7a54d..000000000
--- a/client/platform/desktop/backend/router.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { IncomingMessage, RequestListener, ServerResponse } from 'http';
-import parser from 'url';
-
-class Handler {
-    method: RequestListener;
-
-    constructor(method: RequestListener) {
-      this.method = method;
-    }
-
-    process(req: IncomingMessage, res: ServerResponse) {
-      this.method.apply(this, [req, res]);
-    }
-}
-
-const handlers: Record<string, Handler> = {};
-
-function register(url: string, method: RequestListener) {
-  handlers[url] = new Handler(method);
-}
-
-function missing() {
-  return new Handler((req, res) => {
-    res.writeHead(404, { 'Content-Type': 'text/plain' });
-    res.write(`No route registered for ${req.url}`);
-    res.end();
-  });
-}
-
-function route(req: IncomingMessage): Handler {
-  let handler;
-  if (req.url) {
-    const url = parser.parse(req.url, true);
-    if (url.pathname) {
-      handler = handlers[url.pathname];
-    }
-  }
-  if (handler === undefined) {
-    return missing();
-  }
-  return handler;
-}
-
-export default {
-  register,
-  route,
-};
diff --git a/client/platform/desktop/backend/serializers/viame.ts b/client/platform/desktop/backend/serializers/viame.ts
index 38265873e..14ac174e6 100644
--- a/client/platform/desktop/backend/serializers/viame.ts
+++ b/client/platform/desktop/backend/serializers/viame.ts
@@ -20,7 +20,13 @@ const PolyRegex = /^(\(poly\)) ((?:[0-9]+\.*[0-9]*\s*)+)/g;
 
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll
 function getCaptureGroups(regexp: RegExp, str: string) {
-  const array = [...str.matchAll(regexp)];
+  const iterable = str.matchAll(regexp);
+  const array = [];
+  let v = iterable.next();
+  while (!v.done) {
+    array.push(v.value);
+    v = iterable.next();
+  }
   if (array.length) {
     return array[0];
   }
diff --git a/client/platform/desktop/backend/server.ts b/client/platform/desktop/backend/server.ts
index f3cb622ef..443b86ce7 100644
--- a/client/platform/desktop/backend/server.ts
+++ b/client/platform/desktop/backend/server.ts
@@ -1,11 +1,21 @@
+import type { AddressInfo } from 'net';
+import http from 'http';
+
+import cors from 'cors';
 import mime from 'mime-types';
 import pump from 'pump';
+import express from 'express';
+import bodyparser from 'body-parser';
 import rangeParser from 'range-parser';
-import http from 'http';
-import fs from 'fs';
-import parser from 'url';
+import fs from 'fs-extra';
+import { SaveDetectionsArgs } from 'viame-web-common/apispec';
 
-import router from './router';
+import settings from './state/settings';
+import common from './native/common';
+
+const app = express();
+const apirouter = express.Router();
+let server: http.Server;
 
 // Only support certain MIME types.
 const supportedMediaTypes = [
@@ -24,60 +34,93 @@ const supportedMediaTypes = [
   'image/webp',
 ];
 
-function fail(res: http.ServerResponse, code: number, message = '') {
-  // eslint-disable-next-line no-param-reassign
-  res.statusCode = code;
-  res.write(message);
-  res.end();
+function makeMediaUrl(filepath: string): string {
+  const addr = server.address() as AddressInfo | null;
+  if (!addr) {
+    throw new Error('server has not initialized yet');
+  }
+  return `http://${addr.address}:${addr.port}/api/media?path=${filepath}`;
+}
+
+function fail(res: express.Response, code: number, message: string) {
+  return res.status(code).json({ message }).end();
 }
 
-/* Global error handler middleware. */
-const withErrorHandler = (handler: http.RequestListener): http.RequestListener => (req, res) => {
+apirouter.get('/', (_, res) => {
+  res.send('Electron REST backend.');
+});
+
+/* LOAD metadata */
+apirouter.get('/dataset/:id/meta', async (req, res) => {
   try {
-    return handler(req, res);
+    const ds = await common.loadMetadata(settings.get(), req.params.id, makeMediaUrl);
+    res.json(ds);
   } catch (err) {
-    console.error('BAD');
-    return fail(res, 500, 'Server error');
+    fail(res, 500, err);
   }
-};
-
-router.register('/api', withErrorHandler((req, res) => {
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.write('ELECTRON_BACKEND');
-  res.end();
-}));
-
-router.register('/api/media', withErrorHandler((req, res) => {
-  const { url } = req;
-  if (!url) {
-    throw new Error('Impossible scenario, req.url was empty');
+});
+
+/* SAVE metadata */
+apirouter.post('/dataset/:id/meta', async (req, res) => {
+  try {
+    await common.saveMetadata(settings.get(), req.params.id, req.body);
+    res.status(200);
+  } catch (err) {
+    fail(res, 500, err);
+  }
+});
+
+/* SAVE detections */
+apirouter.post('/dataset/:id/detections', async (req, res) => {
+  try {
+    const args = req.body as SaveDetectionsArgs;
+    await common.saveDetections(settings.get(), req.params.id, args);
+    return res.status(200);
+  } catch (err) {
+    console.error(err);
+    return fail(res, 500, err);
+    throw err;
   }
+});
 
-  const parsedurl = parser.parse(url, true);
-  let path = parsedurl.query ? parsedurl.query.path : undefined;
+/* IMPORT dataset */
+apirouter.post('/import', async (req, res) => {
+  const { path } = req.query;
+  if (!path || Array.isArray(path)) {
+    return fail(res, 400, `Invalid path: ${path}`);
+  }
+  try {
+    const meta = await common.importMedia(settings.get(), path.toString());
+    return res.json(meta);
+  } catch (err) {
+    return fail(res, 500, err);
+  }
+});
 
-  if (path === undefined || Array.isArray(path)) {
-    return fail(res, 404, `Invalid path: ${path}`);
+/* STREAM media */
+apirouter.get('/media', (req, res) => {
+  let { path } = req.query;
+  if (!path || Array.isArray(path)) {
+    return fail(res, 400, `Invalid path: ${path}`);
   }
+  path = path.toString();
 
-  path = decodeURI(path);
-  let filestat;
+  let filestat: fs.Stats;
   try {
     filestat = fs.statSync(path);
     if (!filestat.isFile()) {
       return fail(res, 404, `Invalid file for path: ${path}`);
     }
   } catch (err) {
-    return fail(res, 404);
+    return fail(res, 404, `No such path ${path}`);
   }
 
-  const type = mime.lookup(path);
-  if (type === false) {
+  const mimetype = mime.lookup(path);
+  if (mimetype === false) {
     return fail(res, 400, `Mime lookup failed for path: ${path}`);
   }
-
-  if (!supportedMediaTypes.includes(type)) {
-    return fail(res, 400, 'Cannot request that mime type');
+  if (!supportedMediaTypes.includes(mimetype)) {
+    return fail(res, 400, 'Cannot request this mime type');
   }
 
   const ranges = req.headers.range && rangeParser(filestat.size, req.headers.range);
@@ -85,10 +128,6 @@ router.register('/api/media', withErrorHandler((req, res) => {
     return fail(res, 400, `Range parse failed: ${req.headers.range}`);
   }
 
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Accept-Ranges', 'bytes');
-  res.setHeader('Content-Type', type);
-
   if (ranges === undefined || ranges === '') {
     res.setHeader('Content-Length', filestat.size);
     if (req.method === 'HEAD') {
@@ -100,18 +139,43 @@ router.register('/api/media', withErrorHandler((req, res) => {
 
   const range = ranges[0];
   // eslint-disable-next-line no-param-reassign
-  res.statusCode = 206;
+  res.status(206);
   res.setHeader('Content-Length', range.end - range.start + 1);
   res.setHeader('Content-Range', `bytes ${range.start}-${range.end}/${filestat.size}`);
-  if (req.method === 'HEAD') return res.end();
+  if (req.method === 'HEAD') {
+    return res.end();
+  }
   pump(fs.createReadStream(path, range), res);
   return null;
-}));
-
-// We need a server which relies on our router
-const server = http.createServer((req, res) => {
-  const handler = router.route(req);
-  handler.process(req, res);
 });
 
-export default server;
+if (process.env.NODE_ENV === 'development') {
+  /**
+   * CORS * is dangerous and should be disabled in production.
+   * In prod, the app is loaded from file:/// which is not limited
+   * to same-origin policy like pages loaded via http.
+   *
+   * NOTE: process.env.NODE_ENV doesn't work in production
+   * You cannot check the inverse i.e. !== 'production'
+  */
+  app.use(cors({ origin: '*' }));
+}
+app.use(bodyparser.json());
+app.use('/api', apirouter);
+
+/* Singleton listen function will only create a server once */
+function listen(callback: (server: http.Server) => void) {
+  if (!server) {
+    server = app.listen(0, 'localhost', () => callback(server));
+  } else {
+    callback(server);
+  }
+}
+
+function close() {
+  if (server) {
+    server.close();
+  }
+}
+
+export { listen, close };
diff --git a/client/platform/desktop/backend/state/settings.ts b/client/platform/desktop/backend/state/settings.ts
new file mode 100644
index 000000000..dfeb8ff87
--- /dev/null
+++ b/client/platform/desktop/backend/state/settings.ts
@@ -0,0 +1,19 @@
+import type { Settings } from 'platform/desktop/constants';
+
+let settings: Settings | undefined;
+
+function get(): Settings {
+  if (settings === undefined) {
+    throw new Error('settings has not been initialized.');
+  }
+  return settings;
+}
+
+function set(s: Settings) {
+  settings = s;
+}
+
+export default {
+  get,
+  set,
+};
diff --git a/client/platform/desktop/background.ts b/client/platform/desktop/background.ts
index c70995428..38d9187cf 100644
--- a/client/platform/desktop/background.ts
+++ b/client/platform/desktop/background.ts
@@ -4,7 +4,7 @@ import {
 import { createProtocol } from 'vue-cli-plugin-electron-builder/lib';
 import installExtension, { VUEJS_DEVTOOLS } from 'electron-devtools-installer';
 
-import server from './backend/server';
+import { listen, close } from './backend/server';
 import ipcListen from './backend/ipcService';
 
 app.commandLine.appendSwitch('no-sandbox');
@@ -23,7 +23,7 @@ protocol.registerSchemesAsPrivileged([
 ]);
 
 function cleanup() {
-  server.close();
+  close();
   app.quit();
 }
 
@@ -38,8 +38,7 @@ function createWindow() {
       // Use pluginOptions.nodeIntegration, leave this alone
       // See nklayman.github.io/vue-cli-plugin-electron-builder/guide/security.html
       // #node-integration for more info
-      nodeIntegration: (process.env
-        .ELECTRON_NODE_INTEGRATION as unknown) as boolean,
+      nodeIntegration: (!!process.env.ELECTRON_NODE_INTEGRATION),
       plugins: true,
       enableRemoteModule: true,
     },
@@ -59,7 +58,7 @@ function createWindow() {
     win = null;
   });
 
-  server.listen(0, () => {
+  listen((server) => {
     let address = server.address();
     let port = 0;
     if (typeof address === 'object' && address !== null) {
diff --git a/client/platform/desktop/constants.ts b/client/platform/desktop/constants.ts
index 54ab0a034..768ef5537 100644
--- a/client/platform/desktop/constants.ts
+++ b/client/platform/desktop/constants.ts
@@ -1,4 +1,6 @@
-import { DatasetMeta } from 'viame-web-common/apispec';
+import type {
+  DatasetMeta, DatasetMetaMutable, DatasetType, Pipe,
+} from 'viame-web-common/apispec';
 
 export const websafeVideoTypes = [
   'video/mp4',
@@ -15,7 +17,14 @@ export const websafeImageTypes = [
   // 'image/webp',
 ];
 
+export const otherImageTypes = [
+  'image/avif',
+  'image/tiff',
+];
+
+export const JsonMetaCurrentVersion = 1;
 export const SettingsCurrentVersion = 1;
+
 export interface Settings {
   // version a schema version
   version: number;
@@ -25,17 +34,56 @@ export interface Settings {
   dataPath: string;
 }
 
-export interface DesktopDataset {
-  // name filename (for video) or folder name (for images)
+/**
+ * JsonMeta is a SUBSET of DatasetMeta contained within
+ * the JsonFileSchema.  The remaining parts of DatasetMeta must
+ * be generated at load time.
+ */
+export interface JsonMeta extends DatasetMetaMutable {
+  // version used to manage schema migrations
+  version: number;
+
+  // immutable dataset type
+  type: DatasetType;
+
+  // immutable datset identifier
+  id: string;
+
+  // this will become mutable in the future.
+  fps: number;
+
+  // the original name derived from media path
   name: string;
-  // basePath path of dataset working directory
-  basePath: string;
-  // vidoPath path of single video file
-  videoPath?: string;
-  // meta DatasetMeta
-  meta: DatasetMeta;
+
+  // the import time of the dataset
+  createdAt: string;
+
+  // absolute base path on disk where dataset was imported from
+  originalBasePath: string;
+
+  // video file path
+  // relateive to originalBasePath
+  originalVideoFile: string;
+
+  // output of web safe transcoding
+  // relative to project path
+  transcodedVideoFile?: string;
+
+  // ordered image filenames IF this is an image dataset
+  // relative to originalBasePath
+  originalImageFiles: string[];
+
+  // ordered image filenames of transcoded images
+  // relative to project path
+  transcodedImageFiles?: string[];
+
+  // If the dataset required transcoding, specify the job
+  // key that ran transcoding
+  transcodingJobKey?: string;
 }
 
+export type DesktopMetadata = DatasetMeta & JsonMeta;
+
 interface NvidiaSmiTextRecord {
   _text: string;
 }
@@ -60,8 +108,8 @@ export interface DesktopJob {
   key: string;
   // jobType identify type of job
   jobType: 'pipeline' | 'training';
-  // pipelineName of the pipe or job being run
-  pipelineName: string;
+  // pipe
+  pipeline: Pipe;
   // datasetIds of the involved datasets
   datasetIds: string[];
   // pid of the process spawned
@@ -83,6 +131,5 @@ export interface DesktopJobUpdate extends DesktopJob {
 
 export interface RunPipeline {
   datasetId: string;
-  pipelineName: string;
-  settings: Settings;
+  pipeline: Pipe;
 }
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
new file mode 100644
index 000000000..b023efe1a
--- /dev/null
+++ b/client/platform/desktop/frontend/api.ts
@@ -0,0 +1,147 @@
+import type { FileFilter } from 'electron';
+
+import axios, { AxiosInstance } from 'axios';
+import { ipcRenderer, remote } from 'electron';
+
+import type {
+  Attribute, DatasetMetaMutable, DatasetType,
+  Pipe, Pipelines, SaveDetectionsArgs, TrainingConfigs,
+} from 'viame-web-common/apispec';
+
+import {
+  DesktopJob, DesktopMetadata, JsonMeta, NvidiaSmiReply, RunPipeline, websafeVideoTypes,
+} from 'platform/desktop/constants';
+
+/**
+ * Native functions that run entirely in the renderer
+ */
+
+async function openFromDisk(datasetType: DatasetType) {
+  let filters: FileFilter[] = [];
+  if (datasetType === 'video') {
+    filters = [
+      { name: 'Videos', extensions: websafeVideoTypes.map((str) => str.split('/')[1]) },
+    ];
+  }
+  const results = await remote.dialog.showOpenDialog({
+    properties: [datasetType === 'video' ? 'openFile' : 'openDirectory'],
+    filters,
+  });
+  return results;
+}
+
+/**
+ * IPC api for small-body messages
+ */
+
+function nvidiaSmi(): Promise<NvidiaSmiReply> {
+  return ipcRenderer.invoke('nvidia-smi');
+}
+
+function openLink(url: string): Promise<void> {
+  return ipcRenderer.invoke('open-link-in-browser', url);
+}
+
+async function getPipelineList(): Promise<Pipelines> {
+  return ipcRenderer.invoke('get-pipeline-list');
+}
+
+async function runPipeline(itemId: string, pipeline: Pipe) {
+  const args: RunPipeline = {
+    pipeline,
+    datasetId: itemId,
+  };
+  const job: DesktopJob = await ipcRenderer.invoke('run-pipeline', args);
+  return job;
+}
+
+/**
+ * REST api for larger-body messages
+ */
+
+/**
+ * Initialize an axios client instance given the server
+ * address details fetched from backend over ipc
+ */
+let _axiosClient: AxiosInstance; // do not use elsewhere
+async function getClient(): Promise<AxiosInstance> {
+  if (_axiosClient === undefined) {
+    const addr = await ipcRenderer.invoke('server-info');
+    const baseURL = `http://${addr.address}:${addr.port}/api`;
+    _axiosClient = axios.create({ baseURL });
+  }
+  return _axiosClient;
+}
+
+async function loadMetadata(id: string) {
+  const client = await getClient();
+  const { data } = await client.get<DesktopMetadata>(`dataset/${id}/meta`);
+  return data;
+}
+
+async function saveMetadata(id: string, args: DatasetMetaMutable) {
+  const client = await getClient();
+  return client.post(`dataset/${id}/meta`, args);
+}
+
+async function saveDetections(id: string, args: SaveDetectionsArgs) {
+  const client = await getClient();
+  return client.post(`dataset/${id}/detections`, args);
+}
+
+async function importMedia(path: string): Promise<JsonMeta> {
+  const client = await getClient();
+  const { data } = await client.post<JsonMeta>('import', undefined, {
+    params: { path },
+  });
+  return data;
+}
+
+/**
+ * Unimplemented sections of the API
+ */
+
+async function getAttributes() {
+  return Promise.resolve([] as Attribute[]);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function setAttribute({ addNew, data }: {addNew: boolean | undefined; data: Attribute}) {
+  return Promise.resolve();
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function deleteAttribute(data: Attribute) {
+  return Promise.resolve([] as Attribute[]);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function getTrainingConfigurations(): Promise<TrainingConfigs> {
+  return Promise.resolve({ configs: [], default: '' });
+}
+
+async function runTraining(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  folderIds: string[], pipelineName: string, config: string,
+): Promise<unknown> {
+  return Promise.resolve();
+}
+
+export {
+  /* Standard Specification APIs */
+  loadMetadata,
+  getAttributes,
+  setAttribute,
+  deleteAttribute,
+  getPipelineList,
+  runPipeline,
+  getTrainingConfigurations,
+  runTraining,
+  saveMetadata,
+  saveDetections,
+  /* Nonstandard APIs */
+  importMedia,
+  openFromDisk,
+  openLink,
+  nvidiaSmi,
+};
diff --git a/client/platform/desktop/components/BrowserLink.vue b/client/platform/desktop/frontend/components/BrowserLink.vue
similarity index 93%
rename from client/platform/desktop/components/BrowserLink.vue
rename to client/platform/desktop/frontend/components/BrowserLink.vue
index 3ba22ee5d..48faf1cd3 100644
--- a/client/platform/desktop/components/BrowserLink.vue
+++ b/client/platform/desktop/frontend/components/BrowserLink.vue
@@ -1,7 +1,7 @@
 <script lang="ts">
 import { defineComponent, PropType } from '@vue/composition-api';
 
-import { openLink } from '../api/main';
+import { openLink } from '../api';
 
 export default defineComponent({
   props: {
diff --git a/client/platform/desktop/components/JobTab.vue b/client/platform/desktop/frontend/components/JobTab.vue
similarity index 100%
rename from client/platform/desktop/components/JobTab.vue
rename to client/platform/desktop/frontend/components/JobTab.vue
diff --git a/client/platform/desktop/components/Jobs.vue b/client/platform/desktop/frontend/components/Jobs.vue
similarity index 94%
rename from client/platform/desktop/components/Jobs.vue
rename to client/platform/desktop/frontend/components/Jobs.vue
index ac8a2a3fe..2b6309f47 100644
--- a/client/platform/desktop/components/Jobs.vue
+++ b/client/platform/desktop/frontend/components/Jobs.vue
@@ -4,6 +4,7 @@ import { defineComponent, ref, onBeforeUnmount } from '@vue/composition-api';
 import BrowserLink from './BrowserLink.vue';
 import NavigationBar from './NavigationBar.vue';
 
+import { datasets } from '../store/dataset';
 import { recentHistory } from '../store/jobs';
 
 export default defineComponent({
@@ -23,6 +24,7 @@ export default defineComponent({
 
     return {
       clockDriver,
+      datasets,
       recentHistory,
       moment,
       utc,
@@ -81,12 +83,12 @@ export default defineComponent({
                 </v-col>
                 <v-col cols="8">
                   <v-card-title class="primary--text text--lighten-3 text-decoration-none pt-0">
-                    {{ job.datasets[0].name }}
+                    {{ datasets[job.datasets[0]].name }}
                   </v-card-title>
                   <v-card-subtitle>
-                    [pipe] {{ job.job.pipelineName }}
+                    [pipe] {{ job.job.pipeline.name }}
                     <br>[pid] {{ job.job.pid }}
-                    <br>[path] {{ job.datasets[0].basePath }}
+                    <br>[path] {{ datasets[job.datasets[0]].originalBasePath }}
                   </v-card-subtitle>
                 </v-col>
                 <v-col cols="3">
diff --git a/client/platform/desktop/components/NavigationBar.vue b/client/platform/desktop/frontend/components/NavigationBar.vue
similarity index 100%
rename from client/platform/desktop/components/NavigationBar.vue
rename to client/platform/desktop/frontend/components/NavigationBar.vue
diff --git a/client/platform/desktop/components/Recent.vue b/client/platform/desktop/frontend/components/Recent.vue
similarity index 81%
rename from client/platform/desktop/components/Recent.vue
rename to client/platform/desktop/frontend/components/Recent.vue
index 1cdbcd959..7816d1d31 100644
--- a/client/platform/desktop/components/Recent.vue
+++ b/client/platform/desktop/frontend/components/Recent.vue
@@ -4,7 +4,7 @@ import { defineComponent } from '@vue/composition-api';
 
 import { DatasetType } from 'viame-web-common/apispec';
 
-import { openFromDisk } from '../api/main';
+import { openFromDisk, importMedia } from '../api';
 import { getRecents } from '../store/dataset';
 import BrowserLink from './BrowserLink.vue';
 import NavigationBar from './NavigationBar.vue';
@@ -19,9 +19,10 @@ export default defineComponent({
     async function open(dstype: DatasetType) {
       const ret = await openFromDisk(dstype);
       if (!ret.canceled) {
+        const meta = await importMedia(ret.filePaths[0]);
         root.$router.push({
           name: 'viewer',
-          params: { path: ret.filePaths[0] },
+          params: { id: meta.id },
         });
       }
     }
@@ -93,7 +94,7 @@ export default defineComponent({
             </h2>
             <div
               v-for="recent in recents"
-              :key="recent.dir + recent.base"
+              :key="recent.id"
               class="pa-1"
             >
               <h3 class="text-body-1">
@@ -101,15 +102,23 @@ export default defineComponent({
                   class="pr-2"
                   color="primary lighten-2"
                 >
-                  {{ recent.ext ? 'mdi-file-video' : 'mdi-folder-open' }}
+                  {{
+                    (recent.type === 'video')
+                      ? 'mdi-file-video'
+                      : (recent.originalImageFiles.length > 1)
+                        ? 'mdi-image-multiple'
+                        : 'mdi-image'
+                  }}
                 </v-icon>
                 <router-link
-                  :to="{ name: 'viewer', params: { path: join(recent.dir, recent.base) } }"
+                  :to="{ name: 'viewer', params: { id: recent.id } }"
                   class="primary--text text--lighten-3 text-decoration-none"
                 >
-                  {{ recent.base }}
+                  {{ recent.name }}
                 </router-link>
-                <span class="grey--text px-4">{{ recent.dir }}</span>
+                <span class="grey--text px-4">
+                  {{ recent.originalBasePath }}
+                </span>
               </h3>
             </div>
           </v-card>
diff --git a/client/platform/desktop/components/Settings.vue b/client/platform/desktop/frontend/components/Settings.vue
similarity index 83%
rename from client/platform/desktop/components/Settings.vue
rename to client/platform/desktop/frontend/components/Settings.vue
index 40bae633c..8e81b38a7 100644
--- a/client/platform/desktop/components/Settings.vue
+++ b/client/platform/desktop/frontend/components/Settings.vue
@@ -4,10 +4,10 @@ import {
 } from '@vue/composition-api';
 
 import { remote } from 'electron';
-import { NvidiaSmiReply } from '../constants';
+import { NvidiaSmiReply } from 'platform/desktop/constants';
 
 import { settings, setSettings, validateSettings } from '../store/settings';
-import { nvidiaSmi } from '../api/main';
+import { nvidiaSmi } from '../api';
 
 import BrowserLink from './BrowserLink.vue';
 import NavigationBar from './NavigationBar.vue';
@@ -30,13 +30,13 @@ export default defineComponent({
       smi.value = await nvidiaSmi();
     });
 
-    async function openPath() {
+    async function openPath(name: 'viamePath' | 'dataPath') {
       const result = await remote.dialog.showOpenDialog({
         properties: ['openDirectory'],
-        defaultPath: localSettings.value.viamePath,
+        defaultPath: localSettings.value[name],
       });
       if (!result.canceled) {
-        [localSettings.value.viamePath] = result.filePaths;
+        [localSettings.value[name]] = result.filePaths;
       }
     }
 
@@ -86,15 +86,39 @@ export default defineComponent({
                 block
                 color="primary"
                 class="mb-6"
-                @click="openPath()"
+                @click="openPath('viamePath')"
               >
-                Open
+                Choose
+                <v-icon class="ml-2">
+                  mdi-folder-open
+                </v-icon>
+              </v-btn>
+            </v-col>
+          </v-row>
+          <v-row>
+            <v-col cols="9">
+              <v-text-field
+                v-model="localSettings.dataPath"
+                label="Project Data Storage Path"
+                hint="project annotation and metadata goes here."
+                dense
+                persistent-hint
+              />
+            </v-col>
+            <v-col>
+              <v-btn
+                large
+                block
+                color="primary"
+                class="mb-6"
+                @click="openPath('dataPath')"
+              >
+                Choose
                 <v-icon class="ml-2">
                   mdi-folder-open
                 </v-icon>
               </v-btn>
             </v-col>
-            <v-row />
           </v-row>
         </v-card-text>
         <v-card-text>
diff --git a/client/platform/desktop/components/ViewerLoader.vue b/client/platform/desktop/frontend/components/ViewerLoader.vue
similarity index 88%
rename from client/platform/desktop/components/ViewerLoader.vue
rename to client/platform/desktop/frontend/components/ViewerLoader.vue
index 629e28889..3427d9ab1 100644
--- a/client/platform/desktop/components/ViewerLoader.vue
+++ b/client/platform/desktop/frontend/components/ViewerLoader.vue
@@ -14,20 +14,20 @@ export default defineComponent({
     Viewer,
   },
   props: {
-    path: {
+    id: {
       type: String,
       required: true,
     },
   },
   setup(props) {
-    const dataset = getDataset(props.path);
+    const dataset = getDataset(props.id);
     return { dataset };
   },
 });
 </script>
 
 <template>
-  <Viewer :dataset-id="path">
+  <Viewer :dataset-id="id">
     <template #title>
       <v-tabs
         icons-and-text
@@ -51,7 +51,7 @@ export default defineComponent({
       </span>
     </template>
     <template #title-right>
-      <RunPipelineMenu :selected-dataset-ids="[path]" />
+      <RunPipelineMenu :selected-dataset-ids="[id]" />
     </template>
   </Viewer>
 </template>
diff --git a/client/platform/desktop/frontend/store/dataset.ts b/client/platform/desktop/frontend/store/dataset.ts
new file mode 100644
index 000000000..d3bf2d9aa
--- /dev/null
+++ b/client/platform/desktop/frontend/store/dataset.ts
@@ -0,0 +1,58 @@
+import Vue from 'vue';
+import { uniqBy } from 'lodash';
+import Install, { ref, computed } from '@vue/composition-api';
+import { JsonMeta } from 'platform/desktop/constants';
+
+const RecentsKey = 'desktop.recent';
+
+// TODO remove this: this won't be necessary in Vue 3
+Vue.use(Install);
+
+const datasets = ref({} as Record<string, JsonMeta>);
+
+/**
+ * Return reactive variable that will update
+ * if properties of the dataset change
+ * @param id dataset id path
+ */
+function getDataset(id: string) {
+  return computed(() => datasets.value[id]);
+}
+
+/**
+ * Load recent datasets from localstorage
+ */
+function getRecents(): JsonMeta[] {
+  const arr = window.localStorage.getItem(RecentsKey);
+  try {
+    if (arr) {
+      const maybeArr = JSON.parse(arr);
+      if (maybeArr.length) {
+        return maybeArr;
+      }
+    }
+  } catch (err) {
+    return [];
+  }
+  return [];
+}
+
+/**
+ * Add ID to recent datasets
+ * @param id dataset id path
+ */
+function setRecents(meta: JsonMeta) {
+  Vue.set(datasets.value, meta.id, meta);
+  const recents = getRecents();
+  recents.splice(0, 0, meta); // verify that it's a valid path
+  const recentsStrings = uniqBy(recents, ({ id }) => id);
+  window.localStorage.setItem(RecentsKey, JSON.stringify(recentsStrings));
+}
+
+export {
+  datasets,
+  getDataset,
+  getRecents,
+  setRecents,
+  RecentsKey,
+};
diff --git a/client/platform/desktop/frontend/store/index.ts b/client/platform/desktop/frontend/store/index.ts
new file mode 100644
index 000000000..e8f239c5e
--- /dev/null
+++ b/client/platform/desktop/frontend/store/index.ts
@@ -0,0 +1,54 @@
+import { Api, Pipe } from 'viame-web-common/apispec';
+import * as api from 'platform/desktop/frontend/api';
+
+/* Warning, this import involves node.js code for loadDetections (below) */
+import common from 'platform/desktop/backend/native/common';
+
+import { settings } from './settings';
+import { getRecents, setRecents, RecentsKey } from './dataset';
+import { getOrCreateHistory } from './jobs';
+
+/* Run forward migrations on any client-side data stores */
+export async function migrate() {
+  const recents = await getRecents();
+  if (recents.length && typeof recents[0] === 'string') {
+    window.localStorage.setItem(RecentsKey, JSON.stringify([]));
+  }
+}
+
+/**
+ * Wrap API with hooks to use the store
+ */
+export default function wrap(): Api {
+  async function runPipeline(itemId: string, pipeline: Pipe) {
+    const job = await api.runPipeline(itemId, pipeline);
+    getOrCreateHistory(job, job.datasetIds);
+  }
+
+  async function loadMetadata(datasetId: string) {
+    const meta = await api.loadMetadata(datasetId);
+    setRecents(meta);
+    return meta;
+  }
+
+  /**
+   * loadDetections loads JSON data directly from disk into the
+   * renderer thread. It relies on the node runtime being enabled on the browser.
+   *
+   * This is done such that large annotation files do not need to be loaded into memory
+   * twice, serialized and deserialized twice, and transmitted over the local network.
+   *
+   * In a future version, this could me moved to the backend and streamed directly
+   * to the client using something like https://github.com/uhop/stream-json
+   */
+  async function loadDetections(datasetId: string) {
+    return common.loadDetections(settings.value, datasetId);
+  }
+
+  return {
+    ...api,
+    loadDetections,
+    loadMetadata,
+    runPipeline,
+  };
+}
diff --git a/client/platform/desktop/store/jobs.ts b/client/platform/desktop/frontend/store/jobs.ts
similarity index 86%
rename from client/platform/desktop/store/jobs.ts
rename to client/platform/desktop/frontend/store/jobs.ts
index 80c58c4ec..f801d19c2 100644
--- a/client/platform/desktop/store/jobs.ts
+++ b/client/platform/desktop/frontend/store/jobs.ts
@@ -6,7 +6,7 @@ import Vue from 'vue';
 import Install, {
   ref, Ref, set, computed,
 } from '@vue/composition-api';
-import { DesktopDataset, DesktopJob, DesktopJobUpdate } from '../constants';
+import { DesktopJob, DesktopJobUpdate } from 'platform/desktop/constants';
 
 // TODO remove this: this won't be necessary in Vue 3
 Vue.use(Install);
@@ -14,14 +14,14 @@ Vue.use(Install);
 interface DesktopJobHistory {
   job: DesktopJob;
   logs: string[];
-  datasets: DesktopDataset[];
+  datasets: string[];
 }
 
 const jobHistory: Ref<Record<string, DesktopJobHistory>> = ref({});
 const recentHistory = computed(() => Object.values(jobHistory.value));
 const runningJobs = computed(() => recentHistory.value.filter((v) => v.job.exitCode === null));
 
-function getOrCreateHistory(args: DesktopJob, datasets?: DesktopDataset[]): DesktopJobHistory {
+function getOrCreateHistory(args: DesktopJob, datasets?: string[]): DesktopJobHistory {
   let existing = jobHistory.value[args.key];
   if (!existing) {
     set<DesktopJobHistory>(jobHistory.value, args.key, {
diff --git a/client/platform/desktop/store/settings.ts b/client/platform/desktop/frontend/store/settings.ts
similarity index 78%
rename from client/platform/desktop/store/settings.ts
rename to client/platform/desktop/frontend/store/settings.ts
index 06fc7c7df..e4bb96cfe 100644
--- a/client/platform/desktop/store/settings.ts
+++ b/client/platform/desktop/frontend/store/settings.ts
@@ -1,8 +1,7 @@
 import Vue from 'vue';
 import Install, { ref } from '@vue/composition-api';
 import { ipcRenderer } from 'electron';
-
-import { Settings } from '../constants';
+import { Settings } from 'platform/desktop/constants';
 
 // TODO remove this: this won't be necessary in Vue 3
 Vue.use(Install);
@@ -38,17 +37,25 @@ async function init() {
     if (settingsStr) {
       const maybeSettings = JSON.parse(settingsStr);
       if (isSettings(maybeSettings)) {
-        settingsvalue = maybeSettings;
+        settingsvalue = {
+          // Populate from defaults to include any missing properties
+          ...settingsvalue,
+          // Overwrite with explicitly persisted settings
+          ...maybeSettings,
+        };
       }
     }
   } catch {
     // pass
   }
   settings.value = settingsvalue;
+
+  ipcRenderer.send('update-settings', settings.value);
 }
 
 async function setSettings(s: Settings) {
   window.localStorage.setItem(SettingsKey, JSON.stringify(s));
+  ipcRenderer.send('update-settings', settings.value);
 }
 
 // Will be initialized on first import
diff --git a/client/platform/desktop/main.ts b/client/platform/desktop/main.ts
index 4d4a94b2e..8e141b804 100644
--- a/client/platform/desktop/main.ts
+++ b/client/platform/desktop/main.ts
@@ -7,6 +7,7 @@ import vMousetrap from 'viame-web-common/vue-utilities/v-mousetrap';
 
 import vuetify from './plugins/vuetify';
 import router from './router';
+import { migrate } from './frontend/store';
 import App from './App.vue';
 
 Vue.config.productionTip = false;
@@ -15,13 +16,14 @@ Vue.use(snackbarService(vuetify));
 Vue.use(promptService(vuetify));
 Vue.use(vMousetrap);
 
-
-new Vue({
-  vuetify,
-  router,
-  provide: { vuetify },
-  render: (h) => h(App),
-})
-  .$mount('#app')
-  .$snackbarAttach()
-  .$promptAttach();
+migrate().then(() => {
+  new Vue({
+    vuetify,
+    router,
+    provide: { vuetify },
+    render: (h) => h(App),
+  })
+    .$mount('#app')
+    .$snackbarAttach()
+    .$promptAttach();
+});
diff --git a/client/platform/desktop/router.ts b/client/platform/desktop/router.ts
index 9a544aa4c..337979a02 100644
--- a/client/platform/desktop/router.ts
+++ b/client/platform/desktop/router.ts
@@ -1,10 +1,10 @@
 import Vue from 'vue';
 import Router from 'vue-router';
 
-import Jobs from './components/Jobs.vue';
-import Recent from './components/Recent.vue';
-import Settings from './components/Settings.vue';
-import ViewerLoader from './components/ViewerLoader.vue';
+import Jobs from './frontend/components/Jobs.vue';
+import Recent from './frontend/components/Recent.vue';
+import Settings from './frontend/components/Settings.vue';
+import ViewerLoader from './frontend/components/ViewerLoader.vue';
 
 Vue.use(Router);
 
@@ -26,7 +26,7 @@ export default new Router({
       component: Jobs,
     },
     {
-      path: '/viewer/:path',
+      path: '/viewer/:id',
       name: 'viewer',
       component: ViewerLoader,
       props: true,
diff --git a/client/platform/desktop/store/dataset.ts b/client/platform/desktop/store/dataset.ts
deleted file mode 100644
index 1105bc90d..000000000
--- a/client/platform/desktop/store/dataset.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import path from 'path';
-
-import Vue from 'vue';
-import { uniq } from 'lodash';
-import Install, { ref, computed } from '@vue/composition-api';
-import { DesktopDataset } from '../constants';
-
-const RecentsKey = 'desktop.recent';
-
-// TODO remove this: this won't be necessary in Vue 3
-Vue.use(Install);
-
-const dsmap = ref({} as Record<string, DesktopDataset>);
-
-/**
- * Return reactive variable that will update
- * if properties of the dataset change
- * @param id dataset id path
- */
-function getDataset(id: string) {
-  return computed(() => dsmap.value[id]);
-}
-
-/**
- * Load recent datasets from localstorage
- */
-function getRecents(): path.ParsedPath[] {
-  const arr = window.localStorage.getItem(RecentsKey);
-  let returnVal = [] as path.ParsedPath[];
-  try {
-    if (arr) {
-      const maybeArr = JSON.parse(arr);
-      if (maybeArr.length) {
-        returnVal = maybeArr.map((p: string) => path.parse(p));
-      }
-    }
-  } catch (err) {
-    return returnVal;
-  }
-  return returnVal;
-}
-
-/**
- * Add ID to recent datasets
- * @param id dataset id path
- */
-function setRecents(id: string) {
-  const recents = getRecents();
-  recents.splice(0, 0, path.parse(id)); // verify that it's a valid path
-  let recentsStrings = recents.map((r) => path.join(r.dir, r.base));
-  recentsStrings = uniq(recentsStrings);
-  window.localStorage.setItem(RecentsKey, JSON.stringify(recentsStrings));
-}
-
-/**
- * Set properties of in-memory dataset,
- * and persist ID to recents
- * @param id dataset id path
- * @param ds properties
- */
-function setDataset(id: string, ds: DesktopDataset) {
-  Vue.set(dsmap.value, id, ds);
-  setRecents(id);
-}
-
-export {
-  getDataset,
-  setDataset,
-  getRecents,
-};
diff --git a/client/platform/desktop/store/index.ts b/client/platform/desktop/store/index.ts
deleted file mode 100644
index 0c0ac41e3..000000000
--- a/client/platform/desktop/store/index.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { Api, Pipe } from 'viame-web-common/apispec';
-import * as api from '../api/main';
-
-import { settings } from './settings';
-import { setDataset, getDataset } from './dataset';
-import { getOrCreateHistory } from './jobs';
-
-/**
- * Wrap API with hooks to use the store
- */
-export default function wrap(): Api {
-  async function loadMetadata(datasetId: string) {
-    const ds = await api.loadMetadata(datasetId);
-    setDataset(datasetId, ds);
-    return ds.meta;
-  }
-
-  async function getPipelineList() {
-    return api.getPipelineList(settings.value);
-  }
-
-  async function runPipeline(itemId: string, pipeline: Pipe) {
-    const job = await api.runPipeline(itemId, pipeline, settings.value);
-    const datasets = job.datasetIds.map(((id) => getDataset(id).value));
-    getOrCreateHistory(job, datasets);
-  }
-
-  return {
-    ...api,
-    loadMetadata,
-    getPipelineList,
-    runPipeline,
-  };
-}
diff --git a/client/platform/web-girder/App.vue b/client/platform/web-girder/App.vue
index 93374a475..aedfa4524 100644
--- a/client/platform/web-girder/App.vue
+++ b/client/platform/web-girder/App.vue
@@ -6,8 +6,8 @@
 
 <script lang="ts">
 import { defineComponent } from '@vue/composition-api';
-import { DatasetMeta, provideApi } from 'viame-web-common/apispec';
-import { VIAMEDataset } from './store/Dataset';
+import { provideApi } from 'viame-web-common/apispec';
+import { GirderDataset } from './store/Dataset';
 import {
   getAttributes,
   setAttribute,
@@ -27,8 +27,8 @@ export default defineComponent({
   name: 'App',
   components: {},
   setup(_, { root }) {
-    async function loadMetadata(datasetId: string): Promise<DatasetMeta> {
-      const dataset: VIAMEDataset = await root.$store.dispatch('Dataset/load', datasetId);
+    async function loadMetadata(datasetId: string) {
+      const dataset: GirderDataset = await root.$store.dispatch('Dataset/load', datasetId);
       return dataset.meta;
     }
 
diff --git a/client/platform/web-girder/api/viameDetection.service.ts b/client/platform/web-girder/api/viameDetection.service.ts
index 453214953..8cf187ce3 100644
--- a/client/platform/web-girder/api/viameDetection.service.ts
+++ b/client/platform/web-girder/api/viameDetection.service.ts
@@ -1,4 +1,5 @@
-import Track, { TrackData, TrackId } from 'vue-media-annotator/track';
+import { SaveDetectionsArgs } from 'viame-web-common/apispec';
+import { TrackData } from 'vue-media-annotator/track';
 import girderRest from '../plugins/girder';
 
 interface ExportUrlsResponse {
@@ -29,16 +30,9 @@ async function loadDetections(folderId: string, formatting = 'track_json') {
   return data as { [key: string]: TrackData };
 }
 
-async function saveDetections(folderId: string, args: {
-  delete: TrackId[];
-  upsert: Map<TrackId, Track>;
-}) {
-  const serialized = {} as SerializedTrackstore;
-  Array.from(args.upsert.entries()).forEach(([id, track]) => {
-    serialized[id] = track.serialize();
-  });
+async function saveDetections(folderId: string, args: SaveDetectionsArgs) {
   return girderRest.put('viame_detection', {
-    upsert: serialized,
+    upsert: args.upsert,
     delete: args.delete,
   }, {
     params: { folderId },
diff --git a/client/platform/web-girder/store/Dataset.ts b/client/platform/web-girder/store/Dataset.ts
index a37ce4701..808a1317a 100644
--- a/client/platform/web-girder/store/Dataset.ts
+++ b/client/platform/web-girder/store/Dataset.ts
@@ -8,14 +8,17 @@ import { getFolder, getItemDownloadUri } from '../api/girder.service';
 import { getValidWebImages } from '../api/viame.service';
 import { getClipMeta } from '../api/viameDetection.service';
 
-export interface VIAMEDataset extends GirderModel {
-  meta: DatasetMeta;
+export interface GirderDataset extends GirderModel {
+  meta: {
+    ffprobe_info?: Record<string, string>;
+    annotate: boolean;
+  } & DatasetMeta;
 }
 
 const defaultFrameRate = 30;
 
 interface DatasetState {
-  dataset: VIAMEDataset | null;
+  dataset: GirderDataset | null;
 }
 
 const datasetModule: Module<DatasetState, never> = {
@@ -49,13 +52,13 @@ const datasetModule: Module<DatasetState, never> = {
     },
   },
   mutations: {
-    set(state, { dataset }: { dataset: VIAMEDataset }) {
+    set(state, { dataset }: { dataset: GirderDataset }) {
       state.dataset = dataset;
     },
   },
   actions: {
-    async load({ commit }, datasetId: string): Promise<VIAMEDataset> {
-      const dataset = await getFolder(datasetId) as VIAMEDataset;
+    async load({ commit }, datasetId: string): Promise<GirderDataset> {
+      const dataset = await getFolder(datasetId) as GirderDataset;
       let videoUrl = '';
       let imageData = [] as FrameImage[];
 
diff --git a/client/viame-web-common/apispec.ts b/client/viame-web-common/apispec.ts
index 2b8d901e8..a9dc34a79 100644
--- a/client/viame-web-common/apispec.ts
+++ b/client/viame-web-common/apispec.ts
@@ -1,12 +1,11 @@
 import { provide } from '@vue/composition-api';
 
 import { use } from 'vue-media-annotator/provides';
-import Track, { TrackData, TrackId } from 'vue-media-annotator/track';
+import { TrackData, TrackId } from 'vue-media-annotator/track';
 import { CustomStyle } from 'vue-media-annotator/use/useStyling';
 
-const ApiSymbol = Symbol('api');
-
 type DatasetType = 'image-sequence' | 'video';
+type MultiTrackRecord = Record<string, TrackData>;
 
 interface Attribute {
   belongs: 'track' | 'detection';
@@ -27,7 +26,7 @@ interface Category {
   pipes: Pipe[];
 }
 
-export interface TrainingConfigs {
+interface TrainingConfigs {
   configs: string[];
   default: string;
 }
@@ -36,7 +35,7 @@ type Pipelines = Record<string, Category>;
 
 interface SaveDetectionsArgs {
   delete: TrackId[];
-  upsert: Map<TrackId, Track>;
+  upsert: TrackData[];
 }
 
 interface FrameImage {
@@ -44,19 +43,25 @@ interface FrameImage {
   filename: string;
 }
 
+/**
+ * The parts of metadata a user should be able to modify.
+ */
 interface DatasetMetaMutable {
   customTypeStyling?: Record<string, CustomStyle>;
   confidenceFilters?: Record<string, number>;
 }
 
 interface DatasetMeta extends DatasetMetaMutable {
-  type: Readonly<DatasetType>;
-  fps: Readonly<number | string>;
   imageData: FrameImage[];
   videoUrl: string | undefined;
+  type: Readonly<DatasetType>;
+  fps: Readonly<number | string>; // this will become mutable in the future.
 }
 
 interface Api {
+  /**
+   * @deprecated soon attributes will come from loadMetadata()
+   */
   getAttributes(): Promise<Attribute[]>;
   setAttribute({ addNew, data }: {addNew: boolean | undefined; data: Attribute}): Promise<unknown>;
   deleteAttribute(data: Attribute): Promise<unknown>;
@@ -67,13 +72,15 @@ interface Api {
   getTrainingConfigurations(): Promise<TrainingConfigs>;
   runTraining(folderIds: string[], pipelineName: string, config: string): Promise<unknown>;
 
-  loadDetections(datasetId: string): Promise<{ [key: string]: TrackData }>;
-  saveDetections(datasetId: string, args: SaveDetectionsArgs): Promise<unknown>;
-
   loadMetadata(datasetId: string): Promise<DatasetMeta>;
+  loadDetections(datasetId: string): Promise<MultiTrackRecord>;
+
+  saveDetections(datasetId: string, args: SaveDetectionsArgs): Promise<unknown>;
   saveMetadata(datasetId: string, metadata: DatasetMetaMutable): Promise<unknown>;
 }
 
+const ApiSymbol = Symbol('api');
+
 /**
  * provideApi specifies an implementation of the data persistence interface
  * for use in vue-web-common
@@ -88,15 +95,20 @@ function useApi() {
 }
 
 export {
+  provideApi,
+  useApi,
+};
+
+export type {
   Api,
   Attribute,
   DatasetMeta,
   DatasetMetaMutable,
   DatasetType,
   FrameImage,
+  MultiTrackRecord,
   Pipe,
   Pipelines,
   SaveDetectionsArgs,
-  provideApi,
-  useApi,
+  TrainingConfigs,
 };
diff --git a/client/viame-web-common/components/Viewer.vue b/client/viame-web-common/components/Viewer.vue
index 9d796ed1c..105e6ef49 100644
--- a/client/viame-web-common/components/Viewer.vue
+++ b/client/viame-web-common/components/Viewer.vue
@@ -137,20 +137,6 @@ export default defineComponent({
       removeTrack: tsRemoveTrack,
     } = useTrackStore({ markChangesPending });
 
-    async function loadTracks(datasetId: string) {
-      try {
-        const data = await loadDetections(datasetId);
-        if (data !== null) {
-          Object.values(data).forEach(
-            (trackData) => insertTrack(Track.fromJSON(trackData)),
-          );
-        }
-      } catch (err) {
-        loadError.value = err;
-        throw err;
-      }
-    }
-
     const {
       checkedTrackIds,
       checkedTypes,
@@ -169,23 +155,6 @@ export default defineComponent({
       updateCheckedTrackId,
     } = useTrackFilters({ sortedTracks, removeTrack, markChangesPending });
 
-    Promise.all([
-      loadMetadata(props.datasetId),
-      loadTracks(props.datasetId),
-    ]).then(([meta]) => {
-      // tasks to run after dataset and tracks have loaded
-      populateTypeStyles(meta.customTypeStyling);
-      if (meta.customTypeStyling) {
-        importTypes(Object.keys(meta.customTypeStyling), false);
-      }
-      populateConfidenceFilters(meta.confidenceFilters);
-      loaded.value = true;
-      fps.value = meta.fps;
-      imageData.value = meta.imageData;
-      videoUrl.value = meta.videoUrl;
-      datasetType.value = meta.type;
-    });
-
     const {
       selectedTrackId,
       selectTrack,
@@ -338,6 +307,32 @@ export default defineComponent({
       globalHandler,
     );
 
+    /** Trigger data load */
+    Promise.all([
+      loadMetadata(props.datasetId).then((meta) => {
+        populateTypeStyles(meta.customTypeStyling);
+        if (meta.customTypeStyling) {
+          importTypes(Object.keys(meta.customTypeStyling), false);
+        }
+        populateConfidenceFilters(meta.confidenceFilters);
+        fps.value = meta.fps;
+        imageData.value = meta.imageData;
+        videoUrl.value = meta.videoUrl;
+        datasetType.value = meta.type;
+      }),
+      loadDetections(props.datasetId).then((tracks) => {
+        Object.values(tracks).forEach(
+          (trackData) => insertTrack(Track.fromJSON(trackData)),
+        );
+      }),
+    ]).then(() => {
+      loaded.value = true;
+    }).catch((err) => {
+      loaded.value = false;
+      loadError.value = err;
+      throw err;
+    });
+
     return {
       /* props */
       confidenceThreshold,
diff --git a/client/viame-web-common/use/useSave.ts b/client/viame-web-common/use/useSave.ts
index d89c47ac1..df782726a 100644
--- a/client/viame-web-common/use/useSave.ts
+++ b/client/viame-web-common/use/useSave.ts
@@ -15,7 +15,7 @@ export default function useSave(datasetId: Ref<Readonly<string>>) {
   ) {
     if (pendingChangeMap.upsert.size || pendingChangeMap.delete.size) {
       await saveDetections(datasetId.value, {
-        upsert: pendingChangeMap.upsert,
+        upsert: Array.from(pendingChangeMap.upsert).map((pair) => pair[1].serialize()),
         delete: Array.from(pendingChangeMap.delete),
       });
       pendingChangeMap.upsert.clear();
diff --git a/client/vue.config.js b/client/vue.config.js
index 72993633c..ab895ff2d 100644
--- a/client/vue.config.js
+++ b/client/vue.config.js
@@ -40,6 +40,7 @@ module.exports = {
           // https://github.com/nklayman/vue-cli-plugin-electron-builder/issues/188
           // https://github.com/electron-userland/electron-builder/issues/2592
           main: 'background.js',
+          version: '1.4.0',
         },
         linux: {
           target: ['AppImage', 'snap', 'tar.gz'],
diff --git a/client/yarn.lock b/client/yarn.lock
index 6b7774c70..dad99334f 100644
--- a/client/yarn.lock
+++ b/client/yarn.lock
@@ -1837,6 +1837,14 @@
   dependencies:
     "@types/babel-types" "*"
 
+"@types/body-parser@*", "@types/body-parser@^1.19.0":
+  version "1.19.0"
+  resolved "https://registry.yarnpkg.com/@types/body-parser/-/body-parser-1.19.0.tgz#0685b3c47eb3006ffed117cdd55164b61f80538f"
+  integrity sha512-W98JrE0j2K78swW4ukqMleo8R7h/pFETjM2DQ90MF6XK2i4LO4W3gQ71Lt4w3bfm2EvVSyWHplECvB5sK22yFQ==
+  dependencies:
+    "@types/connect" "*"
+    "@types/node" "*"
+
 "@types/caseless@*":
   version "0.12.2"
   resolved "https://registry.yarnpkg.com/@types/caseless/-/caseless-0.12.2.tgz#f65d3d6389e01eeb458bd54dc8f52b95a9463bc8"
@@ -1854,6 +1862,18 @@
   resolved "https://registry.yarnpkg.com/@types/color-name/-/color-name-1.1.1.tgz#1c1261bbeaa10a8055bbc5d8ab84b7b2afc846a0"
   integrity sha512-rr+OQyAjxze7GgWrSaJwydHStIhHq2lvY3BOC2Mj7KnzI7XK0Uw1TOOdI9lDoajEbSWLiYgoo4f1R51erQfhPQ==
 
+"@types/connect@*":
+  version "3.4.34"
+  resolved "https://registry.yarnpkg.com/@types/connect/-/connect-3.4.34.tgz#170a40223a6d666006d93ca128af2beb1d9b1901"
+  integrity sha512-ePPA/JuI+X0vb+gSWlPKOY0NdNAie/rPUqX2GUPpbZwiKTkSPhjXWuee47E4MtE54QVzGCQMQkAL6JhV2E1+cQ==
+  dependencies:
+    "@types/node" "*"
+
+"@types/cors@^2.8.9":
+  version "2.8.9"
+  resolved "https://registry.yarnpkg.com/@types/cors/-/cors-2.8.9.tgz#4bd1fcac72eca8d5bec93e76c7fdcbdc1bc2cd4a"
+  integrity sha512-zurD1ibz21BRlAOIKP8yhrxlqKx6L9VCwkB5kMiP6nZAhoF5MvC7qS1qPA7nRcr1GJolfkQC7/EAL4hdYejLtg==
+
 "@types/csv-parse@^1.2.2":
   version "1.2.2"
   resolved "https://registry.yarnpkg.com/@types/csv-parse/-/csv-parse-1.2.2.tgz#713486235759d615dc8e6a6a979170ada76701d5"
@@ -2120,6 +2140,25 @@
   resolved "https://registry.yarnpkg.com/@types/events/-/events-3.0.0.tgz#2862f3f58a9a7f7c3e78d79f130dd4d71c25c2a7"
   integrity sha512-EaObqwIvayI5a8dCzhFrjKzVwKLxjoG9T6Ppd5CEo07LRKfQ8Yokw54r5+Wq7FaBQ+yXRvQAYPrHwya1/UFt9g==
 
+"@types/express-serve-static-core@*":
+  version "4.17.17"
+  resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.17.17.tgz#6ba02465165b6c9c3d8db3a28def6b16fc9b70f5"
+  integrity sha512-YYlVaCni5dnHc+bLZfY908IG1+x5xuibKZMGv8srKkvtul3wUuanYvpIj9GXXoWkQbaAdR+kgX46IETKUALWNQ==
+  dependencies:
+    "@types/node" "*"
+    "@types/qs" "*"
+    "@types/range-parser" "*"
+
+"@types/express@^4.17.9":
+  version "4.17.9"
+  resolved "https://registry.yarnpkg.com/@types/express/-/express-4.17.9.tgz#f5f2df6add703ff28428add52bdec8a1091b0a78"
+  integrity sha512-SDzEIZInC4sivGIFY4Sz1GG6J9UObPwCInYJjko2jzOf/Imx/dlpume6Xxwj1ORL82tBbmN4cPDIDkLbWHk9hw==
+  dependencies:
+    "@types/body-parser" "*"
+    "@types/express-serve-static-core" "*"
+    "@types/qs" "*"
+    "@types/serve-static" "*"
+
 "@types/fs-extra@^9.0.1":
   version "9.0.2"
   resolved "https://registry.yarnpkg.com/@types/fs-extra/-/fs-extra-9.0.2.tgz#e1e1b578c48e8d08ae7fc36e552b94c6f4621609"
@@ -2201,6 +2240,11 @@
   resolved "https://registry.yarnpkg.com/@types/mime-types/-/mime-types-2.1.0.tgz#9ca52cda363f699c69466c2a6ccdaad913ea7a73"
   integrity sha1-nKUs2jY/aZxpRmwqbM2q2RPqenM=
 
+"@types/mime@*":
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/@types/mime/-/mime-2.0.3.tgz#c893b73721db73699943bfc3653b1deb7faa4a3a"
+  integrity sha512-Jus9s4CDbqwocc5pOAnh8ShfrnMcPHuJYzVcSUU7lrh8Ni5HuIqX3oilL86p3dlTrk0LzHRCgA/GQ7uNCw6l2Q==
+
 "@types/minimatch@*":
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-3.0.3.tgz#3dca0e3f33b200fc7d1139c0cd96c1268cadfd9d"
@@ -2211,6 +2255,13 @@
   resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.0.tgz#69a23a3ad29caf0097f06eda59b361ee2f0639f6"
   integrity sha1-aaI6OtKcrwCX8G7aWbNh7i8GOfY=
 
+"@types/mock-fs@^4.13.0":
+  version "4.13.0"
+  resolved "https://registry.yarnpkg.com/@types/mock-fs/-/mock-fs-4.13.0.tgz#b8b01cd2db588668b2532ecd21b1babd3fffb2c0"
+  integrity sha512-FUqxhURwqFtFBCuUj3uQMp7rPSQs//b3O9XecAVxhqS9y4/W8SIJEZFq2mmpnFVZBXwR/2OyPLE97CpyYiB8Mw==
+  dependencies:
+    "@types/node" "*"
+
 "@types/mousetrap@^1.6.3":
   version "1.6.3"
   resolved "https://registry.yarnpkg.com/@types/mousetrap/-/mousetrap-1.6.3.tgz#3159a01a2b21c9155a3d8f85588885d725dc987d"
@@ -2265,7 +2316,12 @@
   resolved "https://registry.yarnpkg.com/@types/q/-/q-1.5.2.tgz#690a1475b84f2a884fd07cd797c00f5f31356ea8"
   integrity sha512-ce5d3q03Ex0sy4R14722Rmt6MT07Ua+k4FwDfdcToYJcMKNtRVQvJ6JCAPdAmAnbRb6CsX6aYb9m96NGod9uTw==
 
-"@types/range-parser@^1.2.3":
+"@types/qs@*":
+  version "6.9.5"
+  resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.9.5.tgz#434711bdd49eb5ee69d90c1d67c354a9a8ecb18b"
+  integrity sha512-/JHkVHtx/REVG0VVToGRGH2+23hsYLHdyG+GrvoUGlGAd0ErauXDyvHtRI/7H7mzLm+tBCKA7pfcpkQ1lf58iQ==
+
+"@types/range-parser@*", "@types/range-parser@^1.2.3":
   version "1.2.3"
   resolved "https://registry.yarnpkg.com/@types/range-parser/-/range-parser-1.2.3.tgz#7ee330ba7caafb98090bece86a5ee44115904c2c"
   integrity sha512-ewFXqrQHlFsgc09MK5jP5iR7vumV/BYayNC6PgJO2LPe8vrnNFyjQjSppfEngITi0qvfKtzFvgKymGheFM9UOA==
@@ -2285,6 +2341,14 @@
   resolved "https://registry.yarnpkg.com/@types/resize-observer-browser/-/resize-observer-browser-0.1.4.tgz#84879a4d6d4aaefde53d4b29c91c0c4cbcffc26f"
   integrity sha512-rPvqs+1hL/5hbES/0HTdUu4lvNmneiwKwccbWe7HGLWbnsLdqKnQHyWLg4Pj0AMO7PLHCwBM1Cs8orChdkDONg==
 
+"@types/serve-static@*":
+  version "1.13.8"
+  resolved "https://registry.yarnpkg.com/@types/serve-static/-/serve-static-1.13.8.tgz#851129d434433c7082148574ffec263d58309c46"
+  integrity sha512-MoJhSQreaVoL+/hurAZzIm8wafFR6ajiTM1m4A0kv6AGeVBl4r4pOV8bGFrjjq1sGxDTnCoF8i22o0/aE5XCyA==
+  dependencies:
+    "@types/mime" "*"
+    "@types/node" "*"
+
 "@types/source-map@0.5.2":
   version "0.5.2"
   resolved "https://registry.yarnpkg.com/@types/source-map/-/source-map-0.5.2.tgz#973459e744cc7445c85b97f770275b479b138e08"
@@ -3872,7 +3936,7 @@ bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.1.1, bn.js@^4.4.0:
   resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.9.tgz#26d556829458f9d1e81fc48952493d0ba3507828"
   integrity sha512-E6QoYqCKZfgatHTdHzs1RRKP7ip4vvm+EyRUeE2RF0NblwVvb0p6jSVeNTOFxPn26QXN2o6SMfNxKp6kU8zQaw==
 
-body-parser@1.19.0:
+body-parser@1.19.0, body-parser@^1.19.0:
   version "1.19.0"
   resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.19.0.tgz#96b2709e57c9c4e09a6fd66a8fd979844f69f08a"
   integrity sha512-dhEPs72UPbDnAQJ9ZKMNTP6ptJaionhP5cBb541nXPlW60Jepo9RV/a4fX4XWW9CuFNK22krhrj1+rgzifNCsw==
@@ -5146,6 +5210,14 @@ core-util-is@1.0.2, core-util-is@~1.0.0:
   resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
   integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
 
+cors@^2.8.5:
+  version "2.8.5"
+  resolved "https://registry.yarnpkg.com/cors/-/cors-2.8.5.tgz#eac11da51592dd86b9f06f6e7ac293b3df875d29"
+  integrity sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==
+  dependencies:
+    object-assign "^4"
+    vary "^1"
+
 cosmiconfig@^5.0.0:
   version "5.2.1"
   resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-5.2.1.tgz#040f726809c591e77a17c0a3626ca45b4f168b1a"
@@ -11187,6 +11259,11 @@ mkdirp@1.x, mkdirp@^1.0.3, mkdirp@^1.0.4, mkdirp@~1.0.3, mkdirp@~1.0.4:
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
   integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
 
+mock-fs@^4.13.0:
+  version "4.13.0"
+  resolved "https://registry.yarnpkg.com/mock-fs/-/mock-fs-4.13.0.tgz#31c02263673ec3789f90eb7b6963676aa407a598"
+  integrity sha512-DD0vOdofJdoaRNtnWcrXe6RQbpHkPPmtqGq14uRX0F8ZKJ5nv89CVTYl/BZdppDxBDaV0hl75htg3abpEWlPZA==
+
 moment@^2.27.0, moment@^2.29.1:
   version "2.29.1"
   resolved "https://registry.yarnpkg.com/moment/-/moment-2.29.1.tgz#b2be769fa31940be9eeea6469c075e35006fa3d3"
@@ -11610,7 +11687,7 @@ oauth-sign@~0.9.0:
   resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455"
   integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
 
-object-assign@^4.0.1, object-assign@^4.1.0, object-assign@^4.1.1:
+object-assign@^4, object-assign@^4.0.1, object-assign@^4.1.0, object-assign@^4.1.1:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
   integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
@@ -16101,7 +16178,7 @@ validate-npm-package-license@^3.0.1:
     spdx-correct "^3.0.0"
     spdx-expression-parse "^3.0.0"
 
-vary@~1.1.2:
+vary@^1, vary@~1.1.2:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc"
   integrity sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=
diff --git a/server/viame_server/viame_detection.py b/server/viame_server/viame_detection.py
index deb4594fd..9d4a39a9f 100644
--- a/server/viame_server/viame_detection.py
+++ b/server/viame_server/viame_detection.py
@@ -289,17 +289,17 @@ def get_clip_meta(self, folder):
     )
     def save_detection(self, folder, tracks):
         user = self.getCurrentUser()
-        upsert: Dict[str, dict] = tracks.get('upsert', {})
+        upsert: List[dict] = tracks.get('upsert', [])
         delete: List[str] = tracks.get('delete', [])
         track_dict = getTrackData(self._load_detections(folder))
 
         for track_id in delete:
             track_dict.pop(str(track_id), None)
-        for track_id, track in upsert.items():
+        for track in upsert:
             validated: models.Track = models.Track(**track)
-            track_dict[str(track_id)] = validated.dict(exclude_none=True)
+            track_dict[str(validated.trackId)] = validated.dict(exclude_none=True)
 
-        upserted_len = len(upsert.keys())
+        upserted_len = len(upsert)
         deleted_len = len(delete)
 
         if upserted_len or deleted_len: