diff --git a/app/packages/looker/package.json b/app/packages/looker/package.json
index 2f41057ad8..f42a7eec9c 100644
--- a/app/packages/looker/package.json
+++ b/app/packages/looker/package.json
@@ -18,21 +18,27 @@
         "README.md"
     ],
     "dependencies": {
+        "@jimp/tiff": "^0.22.12",
         "@ungap/event-target": "^0.2.2",
         "@xmldom/xmldom": "^0.8.6",
         "copy-to-clipboard": "^3.3.1",
         "decode-tiff": "^0.2.1",
+        "geotiff": "^2.1.3",
         "immutable": "^4.0.0-rc.12",
         "lodash": "^4.17.21",
         "lru-cache": "^11.0.1",
         "mime": "^2.5.2",
         "monotone-convex-hull-2d": "^1.0.1",
+        "tiff": "^6.1.1",
+        "utif": "^3.1.0",
+        "utif2": "^4.1.0",
         "uuid": "^8.3.2"
     },
     "devDependencies": {
         "@rollup/plugin-inject": "^5.0.2",
         "@types/color-string": "^1.5.0",
         "@types/lru-cache": "^7.10.10",
+        "@types/utif": "^3.0.5",
         "@types/uuid": "^8.3.0",
         "buffer": "^6.0.3",
         "prettier": "^2.7.1",
diff --git a/app/packages/looker/src/state.ts b/app/packages/looker/src/state.ts
index 996eb23ef9..84c9af8b48 100644
--- a/app/packages/looker/src/state.ts
+++ b/app/packages/looker/src/state.ts
@@ -2,11 +2,15 @@
  * Copyright 2017-2024, Voxel51, Inc.
  */
 
-import { BufferManager } from "@fiftyone/utilities";
-import { ImaVidFramesController } from "./lookers/imavid/controller";
-import { Overlay } from "./overlays/base";
-
-import { AppError, COLOR_BY, Schema, Stage } from "@fiftyone/utilities";
+import type {
+  AppError,
+  BufferManager,
+  COLOR_BY,
+  Schema,
+  Stage,
+} from "@fiftyone/utilities";
+import type { ImaVidFramesController } from "./lookers/imavid/controller";
+import type { Overlay } from "./overlays/base";
 
 export type Optional<T> = {
   [P in keyof T]?: Optional<T[P]>;
@@ -70,27 +74,6 @@ export type OrthogrpahicProjectionMetadata = {
   normal: [number, number, number];
 };
 
-export type GenericLabel = {
-  [labelKey: string]: {
-    [field: string]: unknown;
-  };
-  // todo: add other label types
-};
-
-export type Sample = {
-  metadata: {
-    width: number;
-    height: number;
-    mime_type?: string;
-  };
-  _id: string;
-  id: string;
-  filepath: string;
-  tags: string[];
-  _label_tags: string[];
-  _media_type: "image" | "video" | "point-cloud" | "3d";
-} & GenericLabel;
-
 export interface LabelData {
   labelId: string;
   field: string;
@@ -127,8 +110,8 @@ export type Action<State extends BaseState> = (
 ) => void;
 
 export enum ControlEventKeyType {
-  HOLD,
-  KEY_DOWN,
+  HOLD = "HOLD",
+  KEY_DOWN = "KEY_DOWN",
 }
 export interface Control<State extends BaseState = BaseState> {
   eventKeys?: string | string[];
diff --git a/app/packages/looker/src/worker/decoders/canvas.ts b/app/packages/looker/src/worker/decoders/canvas.ts
index 93ecd6c0ba..439279fb01 100644
--- a/app/packages/looker/src/worker/decoders/canvas.ts
+++ b/app/packages/looker/src/worker/decoders/canvas.ts
@@ -1,5 +1,4 @@
-import type { OverlayMask } from "../../numpy";
-import { enqueueFetch } from "../pooled-fetch";
+import type { OverlayMask } from "./types";
 
 const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
 /**
@@ -34,13 +33,7 @@ const getPngcolorType = async (blob: Blob): Promise<number | undefined> => {
   return colorType;
 };
 
-const decodeWithCanvas = async (url: string): Promise<OverlayMask> => {
-  const overlayImageFetchResponse = await enqueueFetch({
-    url,
-    options: { priority: "low" },
-  });
-  const blob = await overlayImageFetchResponse.blob();
-
+const decodeWithCanvas = async (blob: Blob): Promise<OverlayMask> => {
   let channels = 4;
 
   if (blob.type === "image/png") {
diff --git a/app/packages/looker/src/worker/decoders/index.ts b/app/packages/looker/src/worker/decoders/index.ts
index 21076d98a0..f96e21c3d2 100644
--- a/app/packages/looker/src/worker/decoders/index.ts
+++ b/app/packages/looker/src/worker/decoders/index.ts
@@ -1,37 +1,13 @@
 import { getSampleSrc } from "@fiftyone/state/src/recoil/utils";
 import { DETECTION, DETECTIONS } from "@fiftyone/utilities";
 import type { Coloring, CustomizeColor } from "../..";
-import type { OverlayMask } from "../../numpy";
 import type { Colorscale } from "../../state";
+import { enqueueFetch } from "../pooled-fetch";
 import { getOverlayFieldFromCls } from "../shared";
 import decodeCanvas from "./canvas";
+import decodeInline from "./inline";
 import decodeTiff from "./tiff";
-
-type Decoder = (url: string) => Promise<OverlayMask>;
-
-const IMAGE_DECODERS: { [key: string]: Decoder } = {
-  jpeg: decodeCanvas,
-  jpg: decodeCanvas,
-  png: decodeCanvas,
-  tif: decodeTiff,
-  tiff: decodeTiff,
-};
-
-async function decodeImage(url: string) {
-  const extension = url.split(".").slice(-1)[0];
-  return IMAGE_DECODERS[extension](url);
-}
-
-export type IntermediateMask = {
-  data: OverlayMask;
-  image: ArrayBuffer;
-};
-
-interface Decodeable {
-  mask_path?: string;
-  map_path?: string;
-  detections?: { mask_path?: string }[];
-}
+import type { BlobDecoder, Decodeables } from "./types";
 
 interface DecodeParameters {
   cls: string;
@@ -39,13 +15,21 @@ interface DecodeParameters {
   colorscale: Colorscale;
   customizeColorSetting: CustomizeColor[];
   field: string;
-  label: Decodeable;
+  label: Decodeables;
   maskPathDecodingPromises?: Promise<void>[];
   maskTargetsBuffers?: ArrayBuffer[];
   overlayCollectionProcessingParams?: { idx: number; cls: string };
   sources: { [path: string]: string };
 }
 
+const IMAGE_DECODERS: { [key: string]: BlobDecoder } = {
+  jpeg: decodeCanvas,
+  jpg: decodeCanvas,
+  png: decodeCanvas,
+  tif: decodeTiff,
+  tiff: decodeTiff,
+};
+
 /**
  * Some label types (example: segmentation, heatmap) can have their overlay
  * data stored on-disk, we want to impute the relevant mask property of these
@@ -74,21 +58,31 @@ const decode = async ({ field, label, ...params }: DecodeParameters) => {
   const overlayPathField = overlayFields.disk;
   const overlayField = overlayFields.canonical;
 
+  const data = label[overlayField];
+  if (typeof data === "string") {
+    const intermediate = decodeInline(data);
+    if (!intermediate) {
+      return;
+    }
+
+    params.maskTargetsBuffers.push(intermediate.data.buffer);
+    label[overlayField] = intermediate;
+    return;
+  }
+
   if (!Object.hasOwn(label, overlayPathField)) {
     return;
   }
 
-  // it's possible we're just re-coloring, in which case re-init mask image
-  // and set bitmap to null
-  if (label[overlayField]?.bitmap && !label[overlayField]?.image) {
+  if (data?.bitmap && !data?.image) {
     const height = label[overlayField].bitmap.height;
     const width = label[overlayField].bitmap.width;
 
     // close the copied bitmap
-    label[overlayField].bitmap.close();
-    label[overlayField].bitmap = null;
+    data.bitmap.close();
+    data.bitmap = null;
 
-    label[overlayField].image = new ArrayBuffer(height * width * 4);
+    data.image = new ArrayBuffer(height * width * 4);
     return;
   }
 
@@ -110,7 +104,13 @@ const decode = async ({ field, label, ...params }: DecodeParameters) => {
 
   // convert absolute file path to a URL that we can "fetch" from
   const overlayImageUrl = getSampleSrc(source || label[overlayPathField]);
-  const overlayMask = await decodeImage(overlayImageUrl);
+  const overlayImageFetchResponse = await enqueueFetch({
+    url: overlayImageUrl,
+    options: { priority: "low" },
+  });
+  const blob = await overlayImageFetchResponse.blob();
+  const extension = overlayImageUrl.split(".").slice(-1)[0];
+  const overlayMask = await IMAGE_DECODERS[extension](blob);
   const [overlayHeight, overlayWidth] = overlayMask.shape;
 
   // set the `mask` property for this label
@@ -120,7 +120,7 @@ const decode = async ({ field, label, ...params }: DecodeParameters) => {
   label[overlayField] = {
     data: overlayMask,
     image: new ArrayBuffer(overlayWidth * overlayHeight * 4),
-  } as IntermediateMask;
+  };
 
   // no need to transfer image's buffer
   // since we'll be constructing ImageBitmap and transfering that
diff --git a/app/packages/looker/src/worker/decoders/inline.ts b/app/packages/looker/src/worker/decoders/inline.ts
new file mode 100644
index 0000000000..74aabd3853
--- /dev/null
+++ b/app/packages/looker/src/worker/decoders/inline.ts
@@ -0,0 +1,23 @@
+import { deserialize } from "./numpy";
+import type { InlineDecodeable, IntermediateMask } from "./types";
+
+export default (inline: InlineDecodeable): IntermediateMask | null => {
+  let base64: string;
+  if (typeof inline === "string") {
+    base64 = inline;
+  } else if (typeof inline?.$binary?.base64 === "string") {
+    base64 = inline.$binary.base64;
+  }
+
+  if (!base64) {
+    return null;
+  }
+
+  const data = deserialize(base64);
+  const [height, width] = data.shape;
+
+  return {
+    data,
+    image: new ArrayBuffer(width * height * 4),
+  };
+};
diff --git a/app/packages/looker/src/numpy.ts b/app/packages/looker/src/worker/decoders/numpy.ts
similarity index 80%
rename from app/packages/looker/src/numpy.ts
rename to app/packages/looker/src/worker/decoders/numpy.ts
index f48c6abce1..94f8365cf5 100644
--- a/app/packages/looker/src/numpy.ts
+++ b/app/packages/looker/src/worker/decoders/numpy.ts
@@ -4,42 +4,7 @@
 
 import { Buffer } from "buffer";
 import pako from "./pako.js";
-
-export { deserialize };
-
-export const ARRAY_TYPES = {
-  Uint8Array,
-  Uint8ClampedArray,
-  Int8Array,
-  Uint16Array,
-  Int16Array,
-  Uint32Array,
-  Int32Array,
-  Float32Array,
-  Float64Array,
-  BigUint64Array,
-  BigInt64Array,
-};
-
-export type TypedArray =
-  | Uint8Array
-  | Uint8ClampedArray
-  | Int8Array
-  | Uint16Array
-  | Int16Array
-  | Uint32Array
-  | Int32Array
-  | Float32Array
-  | Float64Array
-  | BigUint64Array
-  | BigInt64Array;
-
-export interface OverlayMask {
-  buffer: ArrayBuffer;
-  shape: [number, number];
-  channels: number;
-  arrayType: keyof typeof ARRAY_TYPES;
-}
+import type { OverlayMask } from "./types.js";
 
 const DATA_TYPES = {
   // < = little-endian, > = big-endian, | = host architecture
@@ -146,6 +111,6 @@ function parse(array: Uint8Array): OverlayMask {
 /**
  * Deserializes and parses a base64 encoded numpy array
  */
-function deserialize(compressedBase64Array: string): OverlayMask {
+export function deserialize(compressedBase64Array: string): OverlayMask {
   return parse(pako.inflate(Buffer.from(compressedBase64Array, "base64")));
 }
diff --git a/app/packages/looker/src/pako.js b/app/packages/looker/src/worker/decoders/pako.js
similarity index 100%
rename from app/packages/looker/src/pako.js
rename to app/packages/looker/src/worker/decoders/pako.js
diff --git a/app/packages/looker/src/worker/decoders/tiff.ts b/app/packages/looker/src/worker/decoders/tiff.ts
index d6e9fe5b77..ff67d1717d 100644
--- a/app/packages/looker/src/worker/decoders/tiff.ts
+++ b/app/packages/looker/src/worker/decoders/tiff.ts
@@ -1,14 +1,25 @@
-import { getFetchFunction } from "@fiftyone/utilities";
-import { decode } from "decode-tiff";
-import type { OverlayMask } from "../../numpy";
-
-export default async (url: string) => {
-  const buffer: ArrayBuffer = await getFetchFunction()(
-    "GET",
-    url,
-    null,
-    "arrayBuffer"
-  );
-  const result = decode(buffer);
-  return {} as OverlayMask;
+import * as tiff from "geotiff";
+import type { OverlayMask } from "./types";
+
+export default async (blob: Blob) => {
+  const r = await tiff.fromBlob(blob);
+  const image = await r.getImage();
+  console.log(image.getHeight(), image.getWidth());
+  console.log(r);
+  console.log(image);
+
+  console.log();
+
+  const data = await image.readRGB();
+
+  if (!(data instanceof Uint8Array)) {
+    throw new Error("wrong");
+  }
+
+  return {
+    arrayType: "Uint8Array",
+    buffer: data.buffer,
+    shape: [4, 4],
+    channels: 2,
+  } as OverlayMask;
 };
diff --git a/app/packages/looker/src/worker/decoders/types.ts b/app/packages/looker/src/worker/decoders/types.ts
new file mode 100644
index 0000000000..bd1bb7a5aa
--- /dev/null
+++ b/app/packages/looker/src/worker/decoders/types.ts
@@ -0,0 +1,62 @@
+export type BlobDecoder = (url: Blob) => Promise<OverlayMask>;
+
+export const ARRAY_TYPES = {
+  Uint8Array,
+  Uint8ClampedArray,
+  Int8Array,
+  Uint16Array,
+  Int16Array,
+  Uint32Array,
+  Int32Array,
+  Float32Array,
+  Float64Array,
+  BigUint64Array,
+  BigInt64Array,
+};
+
+export type TypedArray =
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int8Array
+  | Uint16Array
+  | Int16Array
+  | Uint32Array
+  | Int32Array
+  | Float32Array
+  | Float64Array
+  | BigUint64Array
+  | BigInt64Array;
+
+export type Decodeables =
+  | {
+      detections?: InstanceDecodeable[];
+    } & InstanceDecodeable;
+
+export interface Decoded {
+  bitmap?: ImageBitmap;
+}
+
+export type InlineDecodeable =
+  | {
+      $binary?: { base64: string };
+    }
+  | string;
+
+interface InstanceDecodeable {
+  map?: Decoded & InlineDecodeable & IntermediateMask;
+  map_path?: string;
+  mask?: Decoded & InlineDecodeable & IntermediateMask;
+  mask_path?: string;
+}
+
+export interface IntermediateMask {
+  data: OverlayMask;
+  image: ArrayBuffer;
+}
+
+export interface OverlayMask {
+  buffer: ArrayBuffer;
+  shape: [number, number];
+  channels: number;
+  arrayType: keyof typeof ARRAY_TYPES;
+}
diff --git a/app/packages/looker/src/worker/deserializer.test.ts b/app/packages/looker/src/worker/deserializer.test.ts
deleted file mode 100644
index 837f28ae76..0000000000
--- a/app/packages/looker/src/worker/deserializer.test.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import * as deserializer from "./deserializer";
-
-describe("filter resolves correctly", () => {
-  it("skips undefined detection", () => {
-    expect(
-      deserializer.DeserializerFactory.Detection(undefined, [])
-    ).toBeUndefined();
-  });
-
-  it("skips undefined detections", () => {
-    expect(
-      deserializer.DeserializerFactory.Detections(undefined, [])
-    ).toBeUndefined();
-  });
-
-  it("skips undefined heatmap", () => {
-    expect(
-      deserializer.DeserializerFactory.Heatmap(undefined, [])
-    ).toBeUndefined();
-  });
-
-  it("skips undefined segmenation", () => {
-    expect(
-      deserializer.DeserializerFactory.Segmentation(undefined, [])
-    ).toBeUndefined();
-  });
-});
diff --git a/app/packages/looker/src/worker/deserializer.ts b/app/packages/looker/src/worker/deserializer.ts
deleted file mode 100644
index a1ffc5e793..0000000000
--- a/app/packages/looker/src/worker/deserializer.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { deserialize } from "../numpy";
-
-const extractSerializedMask = (
-  label: object,
-  maskProp: string
-): string | undefined => {
-  if (typeof label?.[maskProp] === "string") {
-    return label[maskProp];
-  }
-
-  if (typeof label?.[maskProp]?.$binary?.base64 === "string") {
-    return label[maskProp].$binary.base64;
-  }
-
-  return undefined;
-};
-
-export const DeserializerFactory = {
-  Detection: (label, buffers) => {
-    const serializedMask = extractSerializedMask(label, "mask");
-
-    if (serializedMask) {
-      const data = deserialize(serializedMask);
-      const [height, width] = data.shape;
-      label.mask = {
-        data,
-        image: new ArrayBuffer(width * height * 4),
-      };
-      buffers.push(data.buffer);
-    }
-  },
-  Detections: (labels, buffers) => {
-    const list = labels?.detections || [];
-    for (const label of list) {
-      DeserializerFactory.Detection(label, buffers);
-    }
-  },
-  Heatmap: (label, buffers) => {
-    const serializedMask = extractSerializedMask(label, "map");
-
-    if (serializedMask) {
-      const data = deserialize(serializedMask);
-      const [height, width] = data.shape;
-
-      label.map = {
-        data,
-        image: new ArrayBuffer(width * height * 4),
-      };
-
-      buffers.push(data.buffer);
-    }
-  },
-  Segmentation: (label, buffers) => {
-    const serializedMask = extractSerializedMask(label, "mask");
-
-    if (serializedMask) {
-      const data = deserialize(serializedMask);
-      const [height, width] = data.shape;
-
-      label.mask = {
-        data,
-        image: new ArrayBuffer(width * height * 4),
-      };
-
-      buffers.push(data.buffer);
-    }
-  },
-};
diff --git a/app/packages/looker/src/worker/index.ts b/app/packages/looker/src/worker/index.ts
index a7846cd1c5..b1ff98e6c3 100644
--- a/app/packages/looker/src/worker/index.ts
+++ b/app/packages/looker/src/worker/index.ts
@@ -11,6 +11,7 @@ import {
   EMBEDDED_DOCUMENT,
   HEATMAP,
   LABEL_LIST,
+  PANOPTIC_SEGMENTATION,
   SEGMENTATION,
   VALID_LABEL_TYPES,
   getCls,
@@ -29,7 +30,6 @@ import type {
   Sample,
 } from "../state";
 import decodeImages from "./decoders";
-import { DeserializerFactory } from "./deserializer";
 import { painter, resolveColor } from "./painters";
 import type { ResolveColor, ResolveColorMethod } from "./painters/utils";
 import { getOverlayFieldFromCls, mapId } from "./shared";
@@ -99,10 +99,6 @@ const processLabels = async (
         );
       }
 
-      if (cls in DeserializerFactory) {
-        DeserializerFactory[cls](label, maskTargetsBuffers);
-      }
-
       if ([EMBEDDED_DOCUMENT, DYNAMIC_EMBEDDED_DOCUMENT].includes(cls)) {
         const [moreBitmapPromises, moreMaskTargetsBuffers] =
           await processLabels(
@@ -162,6 +158,7 @@ const processLabels = async (
         selectedLabelTags,
       };
       let promise: Promise<void>;
+
       switch (cls) {
         case DETECTION:
           promise = painter.Detection(params);
@@ -172,6 +169,9 @@ const processLabels = async (
         case HEATMAP:
           promise = painter.Heatmap(params);
           break;
+        case PANOPTIC_SEGMENTATION:
+          promise = painter.PanopticSegmentation(params);
+          break;
         case SEGMENTATION:
           promise = painter.Segmentation(params);
           break;
diff --git a/app/packages/looker/src/worker/painters/detection.ts b/app/packages/looker/src/worker/painters/detection.ts
index 7e8dbd2794..e8b10a017b 100644
--- a/app/packages/looker/src/worker/painters/detection.ts
+++ b/app/packages/looker/src/worker/painters/detection.ts
@@ -1,8 +1,8 @@
 import { COLOR_BY, get32BitColor } from "@fiftyone/utilities";
 import colorString from "color-string";
-import { ARRAY_TYPES } from "../../numpy";
 import type { DetectionLabel } from "../../overlays/detection";
 import { getHashLabel, shouldShowLabelTag } from "../../overlays/util";
+import { ARRAY_TYPES } from "../decoders/types";
 import type { Painter } from "./utils";
 import { requestColor } from "./utils";
 
@@ -75,7 +75,7 @@ const detection: Painter<DetectionLabel> = async ({
         const valueColor = setting?.valueColors?.find((l) => {
           if (["none", "null", "undefined"].includes(l.value?.toLowerCase())) {
             return typeof label[key] === "string"
-              ? l.value?.toLowerCase === label[key]
+              ? l.value?.toLowerCase() === label[key]
               : !label[key];
           }
           if (["True", "False"].includes(l.value?.toString())) {
diff --git a/app/packages/looker/src/worker/painters/index.ts b/app/packages/looker/src/worker/painters/index.ts
index 5a3f62b6a2..f78ab71aea 100644
--- a/app/packages/looker/src/worker/painters/index.ts
+++ b/app/packages/looker/src/worker/painters/index.ts
@@ -1,13 +1,15 @@
 import type { DetectionLabel } from "../../overlays/detection";
+import type { IntermediateMask } from "../decoders/types";
 import detection from "./detection";
 import heatmap from "./heatmap";
+import panoptic from "./panoptic";
 import segmentation from "./segmentation";
 import type { Painter } from "./utils";
 import { requestColor, resolveColor } from "./utils";
 
 type Detections = (request: typeof requestColor) => (
   params: Omit<Parameters<Painter<DetectionLabel>>[0], "label"> & {
-    label: { detections: DetectionLabel[] };
+    label: { detections: (DetectionLabel & { mask: IntermediateMask })[] };
   }
 ) => Promise<void>;
 
@@ -32,6 +34,7 @@ export const createPainter = (request: typeof requestColor) => ({
   Detection: detection,
   Detections: detections(request),
   Heatmap: heatmap,
+  PanopticSegmentation: panoptic,
   Segmentation: segmentation,
 });
 
diff --git a/app/packages/looker/src/worker/painters/make-mask-colorer.ts b/app/packages/looker/src/worker/painters/make-mask-colorer.ts
new file mode 100644
index 0000000000..c5573b37b4
--- /dev/null
+++ b/app/packages/looker/src/worker/painters/make-mask-colorer.ts
@@ -0,0 +1,61 @@
+import { COLOR_BY, get32BitColor } from "@fiftyone/utilities";
+import type { TypedArray } from "../../numpy";
+import { convertToHex } from "../../overlays/util";
+import type { Coloring, CustomizeColor } from "../../state";
+import { convertMaskColorsToObject } from "./utils";
+
+type Colorer = {
+  [key in COLOR_BY]: (i: number, targets: TypedArray) => number;
+};
+
+const makeMaskColorer = (
+  coloring: Coloring,
+  fieldColor: number,
+  setting: CustomizeColor
+): Colorer => {
+  const cache: { [i: number]: number } = {};
+
+  const getColor = (i: number) => {
+    if (!(i in cache)) {
+      cache[i] = get32BitColor(
+        convertToHex(
+          coloring.targets[Math.round(Math.abs(i)) % coloring.targets.length]
+        )
+      );
+    }
+
+    return cache[i];
+  };
+
+  // convert the defaultMaskTargetsColors and fields maskTargetsColors into
+  // objects to improve performance
+  const defaultSetting = convertMaskColorsToObject(
+    coloring.defaultMaskTargetsColors
+  );
+  const fieldSetting = convertMaskColorsToObject(setting?.maskTargetsColors);
+
+  return {
+    [COLOR_BY.FIELD]: () => fieldColor,
+    [COLOR_BY.INSTANCE]: (i: number, targets: TypedArray) => {
+      return getColor(Number(targets[i]));
+    },
+    [COLOR_BY.VALUE]: (i: number, targets: TypedArray) => {
+      // Attempt to find a color in the fields mask target color settings
+      // If not found, attempt to find a color in the default mask target
+      // colors
+      const targetString = targets[i].toString();
+      const customColor =
+        fieldSetting?.[targetString] || defaultSetting?.[targetString];
+
+      // If a customized color setting is found, get the 32-bit color
+      // representation
+      if (customColor) {
+        return get32BitColor(convertToHex(customColor));
+      }
+
+      return getColor(targets[i]);
+    },
+  };
+};
+
+export default makeMaskColorer;
diff --git a/app/packages/looker/src/worker/painters/panoptic.ts b/app/packages/looker/src/worker/painters/panoptic.ts
new file mode 100644
index 0000000000..b9e6b5c663
--- /dev/null
+++ b/app/packages/looker/src/worker/painters/panoptic.ts
@@ -0,0 +1,84 @@
+import { COLOR_BY } from "@fiftyone/utilities";
+import type { SegmentationLabel } from "../../overlays/segmentation";
+import type { MaskTargets } from "../../state";
+import type { OverlayMask } from "../decoders/types";
+import { ARRAY_TYPES } from "../decoders/types";
+import makeMaskColorer from "./make-mask-colorer";
+import type { Painter } from "./utils";
+import { getFieldColor, getTargets } from "./utils";
+
+const makeShouldClear = (maskTargets: MaskTargets) => {
+  const isMaskTargetsEmpty = Object.keys(maskTargets).length === 0;
+  return (target: number) => {
+    if (isMaskTargetsEmpty) {
+      return false;
+    }
+
+    return !(target in maskTargets);
+  };
+};
+
+const panoptic: Painter<SegmentationLabel> = async ({
+  field,
+  label,
+  coloring,
+  customizeColorSetting,
+}) => {
+  console.log(label);
+  if (!label?.mask) {
+    return;
+  }
+
+  // the actual overlay that'll be painted, byte-length of width * height * 4
+  // (RGBA channels)
+
+  const maskTargets = getTargets(field, coloring);
+  const maskData: OverlayMask = label.mask.data;
+
+  // target map array
+  const targets = new ARRAY_TYPES[maskData.arrayType](maskData.buffer);
+
+  console.log(targets);
+  const setting = customizeColorSetting.find((x) => x.path === field);
+  const fieldColor = await getFieldColor(field, coloring, setting);
+  console.log(label.mask);
+  const overlay = new Uint32Array(label.mask.image);
+  let colorBy = coloring.by;
+
+  if (maskTargets && Object.keys(maskTargets).length === 1) {
+    colorBy = COLOR_BY.FIELD;
+  }
+
+  const shouldClear = makeShouldClear(maskTargets);
+  const colorer = makeMaskColorer(coloring, fieldColor, setting);
+  const zero = 0;
+
+  let tick = 1;
+  let i = 0;
+  let j = 0;
+
+  if (colorBy === COLOR_BY.INSTANCE) {
+    i = 1;
+  }
+
+  tick = maskData.channels;
+
+  // while loop should be fast
+  while (i < targets.length) {
+    if (targets[i] === zero) {
+      i += tick;
+      j++;
+      continue;
+    }
+
+    if (shouldClear(Number(targets[i]))) {
+      targets[i] = zero;
+    }
+
+    overlay[j] = colorer[colorBy](i, targets);
+    i += tick;
+    j++;
+  }
+};
+
+export default panoptic;
diff --git a/app/packages/looker/src/worker/painters/segmentation.ts b/app/packages/looker/src/worker/painters/segmentation.ts
index c294dad327..2f2c9b2a5c 100644
--- a/app/packages/looker/src/worker/painters/segmentation.ts
+++ b/app/packages/looker/src/worker/painters/segmentation.ts
@@ -1,37 +1,12 @@
 import { COLOR_BY, get32BitColor, rgbToHexCached } from "@fiftyone/utilities";
-import type { OverlayMask, TypedArray } from "../../numpy";
-import { ARRAY_TYPES } from "../../numpy";
 import type { SegmentationLabel } from "../../overlays/segmentation";
-import { convertToHex, isRgbMaskTargets } from "../../overlays/util";
-import type {
-  Coloring,
-  CustomizeColor,
-  MaskTargets,
-  RgbMaskTargets,
-} from "../../state";
+import { isRgbMaskTargets } from "../../overlays/util";
+import type { MaskTargets, RgbMaskTargets } from "../../state";
+import type { OverlayMask, TypedArray } from "../decoders/types";
+import { ARRAY_TYPES } from "../decoders/types";
+import makeMaskColorer from "./make-mask-colorer";
 import type { Painter } from "./utils";
-import {
-  convertMaskColorsToObject,
-  getRgbFromMaskData,
-  requestColor,
-} from "./utils";
-
-const usingBigInts = (targets: TypedArray) => {
-  return targets instanceof BigInt64Array || targets instanceof BigUint64Array;
-};
-
-const getTargets = (field: string, coloring: Coloring) => {
-  // each field may have its own target map
-  let maskTargets: MaskTargets = coloring.maskTargets[field];
-
-  // or, in the absence of field specific targets, use default mask targets
-  // that are dataset scoped
-  if (!maskTargets) {
-    maskTargets = coloring.defaultMaskTargets;
-  }
-
-  return maskTargets;
-};
+import { getFieldColor, getRgbFromMaskData, getTargets } from "./utils";
 
 const getGuard = (maskTargets: MaskTargets) => {
   const isMaskTargetsEmpty = Object.keys(maskTargets).length === 0;
@@ -97,7 +72,6 @@ const segmentation: Painter<SegmentationLabel> = async ({
 
   // the actual overlay that'll be painted, byte-length of width * height * 4
   // (RGBA channels)
-
   const maskTargets = getTargets(field, coloring);
   const maskData: OverlayMask = label.mask.data;
 
@@ -118,25 +92,11 @@ const segmentation: Painter<SegmentationLabel> = async ({
   }
 
   const shouldClear = makeShouldClear(maskTargets);
-  const colorer = makeColorer(coloring, fieldColor, setting);
-  const zero = usingBigInts(targets) ? 0n : 0;
-
-  let tick = 1;
-  let i = 0;
-  let j = 0;
-  if (label.is_panoptic) {
-    if (colorBy === COLOR_BY.INSTANCE) {
-      i = 1;
-    }
-
-    tick = maskData.channels;
-  }
-
-  // while loop should be fast
-  while (i < targets.length) {
+  const colorer = makeMaskColorer(coloring, fieldColor, setting);
+  const zero = 0;
+  // for loop should be fast
+  for (let i = 0; i < targets.length; i++) {
     if (targets[i] === zero) {
-      i += tick;
-      j++;
       continue;
     }
 
@@ -144,9 +104,7 @@ const segmentation: Painter<SegmentationLabel> = async ({
       targets[i] = zero;
     }
 
-    overlay[j] = colorer[colorBy](i, targets);
-    i += tick;
-    j++;
+    overlay[i] = colorer[colorBy](i, targets);
   }
 };
 
@@ -162,72 +120,4 @@ const makeShouldClear = (maskTargets: MaskTargets) => {
   };
 };
 
-type Colorer = {
-  [key in COLOR_BY]: (i: number, targets: TypedArray) => number;
-};
-
-const makeColorer = (
-  coloring: Coloring,
-  fieldColor: number,
-  setting: CustomizeColor
-): Colorer => {
-  const cache: { [i: number]: number } = {};
-
-  const getColor = (i: number) => {
-    if (!(i in cache)) {
-      cache[i] = get32BitColor(
-        convertToHex(
-          coloring.targets[Math.round(Math.abs(i)) % coloring.targets.length]
-        )
-      );
-    }
-
-    return cache[i];
-  };
-
-  // convert the defaultMaskTargetsColors and fields maskTargetsColors into
-  // objects to improve performance
-  const defaultSetting = convertMaskColorsToObject(
-    coloring.defaultMaskTargetsColors
-  );
-  const fieldSetting = convertMaskColorsToObject(setting?.maskTargetsColors);
-
-  return {
-    [COLOR_BY.FIELD]: () => fieldColor,
-    [COLOR_BY.INSTANCE]: (i: number, targets: TypedArray) => {
-      return getColor(Number(targets[i]));
-    },
-    [COLOR_BY.VALUE]: (i: number, targets: TypedArray) => {
-      // Attempt to find a color in the fields mask target color settings
-      // If not found, attempt to find a color in the default mask target
-      // colors
-      const targetString = targets[i].toString();
-      const customColor =
-        fieldSetting?.[targetString] || defaultSetting?.[targetString];
-
-      // If a customized color setting is found, get the 32-bit color
-      // representation
-      if (customColor) {
-        return get32BitColor(convertToHex(customColor));
-      }
-
-      return getColor(targets[i]);
-    },
-  };
-};
-
-const getFieldColor = async (
-  field: string,
-  coloring: Coloring,
-  setting: CustomizeColor
-) => {
-  // if field color has valid custom settings, use the custom field color
-  // convert the color into hex code, since it could be a color name
-  // (e.g. yellowgreen)
-  const fieldColorString = setting?.fieldColor
-    ? setting.fieldColor
-    : await requestColor(coloring.pool, coloring.seed, field);
-  return get32BitColor(convertToHex(fieldColorString));
-};
-
 export default segmentation;
diff --git a/app/packages/looker/src/worker/painters/utils.ts b/app/packages/looker/src/worker/painters/utils.ts
index ea32e98324..d168e067a8 100644
--- a/app/packages/looker/src/worker/painters/utils.ts
+++ b/app/packages/looker/src/worker/painters/utils.ts
@@ -1,5 +1,5 @@
+import { get32BitColor } from "@fiftyone/utilities";
 import colorString from "color-string";
-import type { TypedArray } from "../../numpy";
 import type { RegularLabel } from "../../overlays/base";
 import type {
   Coloring,
@@ -7,7 +7,9 @@ import type {
   CustomizeColor,
   LabelTagColor,
   MaskColorInput,
+  MaskTargets,
 } from "../../state";
+import type { IntermediateMask, TypedArray } from "../decoders/types";
 import type { ReaderMethod } from "../types";
 
 export type Painter<Label extends RegularLabel> = (params: {
@@ -15,7 +17,7 @@ export type Painter<Label extends RegularLabel> = (params: {
   colorscale: Colorscale;
   customizeColorSetting: CustomizeColor[];
   field: string;
-  label: Label;
+  label: Label & { mask: IntermediateMask };
   labelTagColors: LabelTagColor;
   selectedLabelTags: string[];
 }) => Promise<void>;
@@ -55,8 +57,19 @@ export const convertMaskColorsToObject = (array: MaskColorInput[]) => {
   return result;
 };
 
-export const isFloatArray = (arr) =>
-  arr instanceof Float32Array || arr instanceof Float64Array;
+export const getFieldColor = async (
+  field: string,
+  coloring: Coloring,
+  setting: CustomizeColor
+) => {
+  // if field color has valid custom settings, use the custom field color
+  // convert the color into hex code, since it could be a color name
+  // (e.g. yellowgreen)
+  const fieldColorString = setting?.fieldColor
+    ? setting.fieldColor
+    : await requestColor(coloring.pool, coloring.seed, field);
+  return get32BitColor(convertToHex(fieldColorString));
+};
 
 export const getRgbFromMaskData = (
   maskTypedArray: TypedArray,
@@ -70,6 +83,22 @@ export const getRgbFromMaskData = (
   return [r, g, b] as [number, number, number];
 };
 
+export const getTargets = (field: string, coloring: Coloring) => {
+  // each field may have its own target map
+  let maskTargets: MaskTargets = coloring.maskTargets[field];
+
+  // or, in the absence of field specific targets, use default mask targets
+  // that are dataset scoped
+  if (!maskTargets) {
+    maskTargets = coloring.defaultMaskTargets;
+  }
+
+  return maskTargets;
+};
+
+export const isFloatArray = (arr) =>
+  arr instanceof Float32Array || arr instanceof Float64Array;
+
 export const [requestColor, resolveColor] = ((): [
   (
     pool: readonly string[],
diff --git a/app/packages/looker/src/worker/shared.ts b/app/packages/looker/src/worker/shared.ts
index ec383b7536..4541c52595 100644
--- a/app/packages/looker/src/worker/shared.ts
+++ b/app/packages/looker/src/worker/shared.ts
@@ -6,12 +6,16 @@ import { HEATMAP } from "@fiftyone/utilities";
 export const mapId = (obj) => {
   if (obj && obj._id !== undefined) {
     obj.id = obj._id;
-    delete obj._id;
+    obj._id = undefined;
   }
   return obj;
 };
 
-export const getOverlayFieldFromCls = (cls: string) => {
+export const getOverlayFieldFromCls = (
+  cls: string
+):
+  | { canonical: "map"; disk: "map_path" }
+  | { canonical: "mask"; disk: "mask_path" } => {
   switch (cls) {
     case HEATMAP:
       return { canonical: "map", disk: "map_path" };
diff --git a/app/packages/utilities/src/constants.ts b/app/packages/utilities/src/constants.ts
index 759f727a35..f8bc068567 100644
--- a/app/packages/utilities/src/constants.ts
+++ b/app/packages/utilities/src/constants.ts
@@ -44,3 +44,336 @@ export const BOOK_A_DEMO_LINK = "https://voxel51.com/book-a-demo/";
 export const TRY_IN_BROWSER_LINK = "https://voxel51.com/try-fiftyone/";
 export const APP_MODE = "fiftyone";
 export const IS_APP_MODE_FIFTYONE = APP_MODE === "fiftyone";
+export const NONFINITES = new Set(["-inf", "inf", "nan"]);
+
+export const CLASSIFICATION = "Classification";
+export const CLASSIFICATIONS = "Classifications";
+export const DYNAMIC_EMBEDDED_DOCUMENT = "DynamicEmbeddedDocument";
+export const EMBEDDED_DOCUMENT = "EmbeddedDocument";
+export const DETECTION = "Detection";
+export const DETECTIONS = "Detections";
+export const GEOLOCATION = "GeoLocation";
+export const GEOLOCATIONS = "GeoLocations";
+export const HEATMAP = "Heatmap";
+export const KEYPOINT = "Keypoint";
+export const KEYPOINTS = "Keypoints";
+export const PANOPTIC_SEGMENTATION = "PanopticSegmentation";
+export const POLYLINE = "Polyline";
+export const POLYLINES = "Polylines";
+export const REGRESSION = "Regression";
+export const SEGMENTATION = "Segmentation";
+export const TEMPORAL_DETECTION = "TemporalDetection";
+export const TEMPORAL_DETECTIONS = "TemporalDetections";
+
+export const LABEL_LISTS_MAP = {
+  [CLASSIFICATIONS]: "classifications",
+  [DETECTIONS]: "detections",
+  [KEYPOINTS]: "keypoints",
+  [POLYLINES]: "polylines",
+  [TEMPORAL_DETECTIONS]: "detections",
+};
+
+const RESERVED_FIELD_KEYS_MAP = {
+  tags: "tags",
+  filepath: "filepath",
+  sampleID: "sample_id",
+};
+
+export const RESERVED_FIELD_KEYS = Object.values(RESERVED_FIELD_KEYS_MAP);
+
+export const LABELS_MAP = {
+  [CLASSIFICATION]: CLASSIFICATION,
+  [CLASSIFICATIONS]: CLASSIFICATIONS,
+  [DETECTION]: DETECTION,
+  [DETECTIONS]: DETECTIONS,
+  [GEOLOCATION]: GEOLOCATION,
+  [GEOLOCATIONS]: GEOLOCATIONS,
+  [HEATMAP]: HEATMAP,
+  [KEYPOINT]: KEYPOINT,
+  [KEYPOINTS]: KEYPOINTS,
+  [PANOPTIC_SEGMENTATION]: PANOPTIC_SEGMENTATION,
+  [POLYLINE]: POLYLINE,
+  [POLYLINES]: POLYLINES,
+  [SEGMENTATION]: SEGMENTATION,
+  [REGRESSION]: REGRESSION,
+  [TEMPORAL_DETECTION]: TEMPORAL_DETECTION,
+  [TEMPORAL_DETECTIONS]: TEMPORAL_DETECTIONS,
+};
+
+export const MASK_LABELS = new Set([DETECTION, SEGMENTATION]);
+
+// defined as labels that can have on-disk overlays
+export const DENSE_LABELS = new Set([
+  DETECTION,
+  DETECTIONS,
+  HEATMAP,
+  PANOPTIC_SEGMENTATION,
+  SEGMENTATION,
+]);
+
+export const VALID_OBJECT_TYPES = [
+  DETECTION,
+  DETECTIONS,
+  KEYPOINT,
+  KEYPOINTS,
+  POLYLINE,
+  POLYLINES,
+  TEMPORAL_DETECTION,
+  TEMPORAL_DETECTIONS,
+];
+
+export const VALID_CLASS_TYPES = ["Classification", "Classifications"];
+export const VALID_MASK_TYPES = [
+  "Heatmap",
+  "PanopticSegmentation",
+  "Segmentation",
+];
+export const VALID_LIST_TYPES = [
+  "Classifications",
+  "Detections",
+  "Keypoints",
+  "Polylines",
+  "TemporalDetections",
+];
+
+export const VALID_LABEL_TYPES = [
+  ...VALID_CLASS_TYPES,
+  ...VALID_OBJECT_TYPES,
+  ...VALID_MASK_TYPES,
+  "Regression",
+];
+
+export const LABEL_LISTS = [
+  "Classifications",
+  "Detections",
+  "Keypoints",
+  "Polylines",
+  "TemporalDetections",
+];
+
+export const LABEL_LIST = {
+  Classifications: "classifications",
+  Detections: "detections",
+  Keypoints: "keypoints",
+  Polylines: "polylines",
+  TemporalDetections: "detections",
+};
+
+export const LABEL_LIST_PATH = Object.fromEntries(
+  Object.entries(LABEL_LIST).map(([docType, field]) => [
+    withPath("fiftyone.core.labels", docType),
+    field,
+  ])
+);
+
+export const NOT_VISIBLE_LIST = [
+  "DictField",
+  "ArrayField",
+  "VectorField",
+  "FrameNumberField",
+];
+
+export const LABEL_DOC_TYPES = VALID_LABEL_TYPES.filter(
+  (label) => !LABEL_LISTS.includes(label)
+);
+
+export const AGGS = {
+  BOUNDS: "Bounds",
+  COUNT: "Count",
+  COUNT_VALUES: "CountValues",
+  DISTINCT: "Distinct",
+};
+
+export const VALID_LIST_FIELDS = [FRAME_SUPPORT_FIELD, LIST_FIELD];
+
+export const VALID_NON_LIST_LABEL_TYPES = [
+  CLASSIFICATION_FIELD,
+  DETECTION_FIELD,
+  GEO_LOCATION_FIELD,
+  KEYPOINT_FIELD,
+  HEATMAP_FIELD,
+  PANOPTIC_SEGMENTATION_FIELD,
+  POLYLINE_FIELD,
+  REGRESSION_FIELD,
+  SEGMENTATION_FIELD,
+  TEMPORAL_DETECTION_FIELD,
+];
+
+export const VALID_LIST_LABEL_FIELDS = [
+  DETECTIONS_FIELD,
+  CLASSIFICATIONS_FIELD,
+  KEYPOINTS_FIELD,
+  TEMPORAL_DETECTIONS_FIELD,
+  GEO_LOCATIONS_FIELD,
+  POLYLINES_FIELD,
+];
+
+export const DISABLED_LABEL_FIELDS_VISIBILITY = [
+  ...VALID_NON_LIST_LABEL_TYPES,
+  ...VALID_LIST_LABEL_FIELDS,
+];
+
+export const VALID_PRIMITIVE_TYPES = [
+  BOOLEAN_FIELD,
+  DATE_FIELD,
+  DATE_TIME_FIELD,
+  FLOAT_FIELD,
+  FRAME_NUMBER_FIELD,
+  FRAME_SUPPORT_FIELD,
+  INT_FIELD,
+  OBJECT_ID_FIELD,
+  STRING_FIELD,
+];
+
+export const VALID_DISTRIBUTION_TYPES = [
+  BOOLEAN_FIELD,
+  DATE_FIELD,
+  DATE_TIME_FIELD,
+  FLOAT_FIELD,
+  FRAME_NUMBER_FIELD,
+  FRAME_SUPPORT_FIELD,
+  INT_FIELD,
+  STRING_FIELD,
+];
+
+export const VALID_NUMERIC_TYPES = [
+  DATE_FIELD,
+  DATE_TIME_FIELD,
+  FLOAT_FIELD,
+  FRAME_NUMBER_FIELD,
+  FRAME_SUPPORT_FIELD,
+  INT_FIELD,
+];
+
+// list fields may not have a subfield type, so null, undefined is included
+export const UNSUPPORTED_FILTER_TYPES = [
+  ARRAY_FIELD,
+  DICT_FIELD,
+  VECTOR_FIELD,
+  null,
+  undefined,
+];
+
+export const SKIP_FIELD_TYPES = [...UNSUPPORTED_FILTER_TYPES, JUST_FIELD];
+
+export const DYNAMIC_GROUP_FIELDS = [
+  BOOLEAN_FIELD,
+  FLOAT_FIELD,
+  FRAME_NUMBER_FIELD,
+  INT_FIELD,
+  OBJECT_ID_FIELD,
+  STRING_FIELD,
+];
+
+export const LABELS_PATH = "fiftyone.core.labels";
+
+export const PATCHES_FIELDS = withPath(LABELS_PATH, [
+  "Detections",
+  "Polylines",
+]);
+export const CLIPS_SAMPLE_FIELDS = withPath(LABELS_PATH, [
+  "TemporalDetections",
+]);
+export const CLIPS_FRAME_FIELDS = withPath(LABELS_PATH, [
+  "Classifications",
+  "Detections",
+  "Keypoints",
+  "Polylines",
+]);
+
+export const DISABLED_PATHS = ["id", "filepath", "tags", "metadata"];
+
+const BASE_DISABLED_PATHS = ["id", "tags", "label", "confidence"];
+
+export const DETECTION_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "bounding_box",
+  "mask",
+  "index",
+];
+
+export const POLYLINE_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "points",
+  "closed",
+  "filled",
+  "index",
+];
+
+export const CLASSIFICATION_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "logits",
+];
+
+export const REGRESSION_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "value",
+  "confidence",
+];
+
+export const KEYPOINT_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "points",
+  "index",
+];
+
+export const PANOPTIC_SEGMENTATION_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "mask",
+  "mask_path",
+];
+
+export const SEGMENTATION_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "mask",
+  "mask_path",
+];
+
+export const HEATMAP_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "map",
+  "map_path",
+  "range",
+];
+
+export const TEMPORAL_DETECTION_DISABLED_SUB_PATHS = [
+  ...BASE_DISABLED_PATHS,
+  "support",
+];
+
+export const GEOLOCATION_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "point",
+  "line",
+  "polygon",
+];
+
+export const GEOLOCATIONS_DISABLED_SUB_PATHS = [
+  "id",
+  "tags",
+  "point",
+  "line",
+  "polygons",
+];
+export const BUILT_IN_PANEL_PRIORITY_CONST = 51000;
+
+export function withPath(path: string, types: string): string;
+export function withPath(path: string, types: string[]): string[];
+export function withPath(
+  path: string,
+  types: string | string[]
+): string | string[] {
+  if (Array.isArray(types)) {
+    return types.map((type) => [path, type].join("."));
+  }
+
+  return [path, types].join(".");
+}
+
+export const LABELS = withPath(LABELS_PATH, VALID_LABEL_TYPES);
+export const VALID_KEYPOINTS = withPath(LABELS_PATH, [KEYPOINT, KEYPOINTS]);
diff --git a/app/packages/utilities/src/index.ts b/app/packages/utilities/src/index.ts
index 65546d7176..edfec1e8c9 100644
--- a/app/packages/utilities/src/index.ts
+++ b/app/packages/utilities/src/index.ts
@@ -1,10 +1,16 @@
-import { Sample } from "@fiftyone/looker/src/state";
 import _ from "lodash";
 import mime from "mime";
-import { Field } from "./schema";
+import {
+  DATE_FIELD,
+  DATE_TIME_FIELD,
+  EMBEDDED_DOCUMENT_FIELD,
+  FRAME_SUPPORT_FIELD,
+} from "./constants";
+import type { Field, Sample } from "./schema";
 
 export * from "./buffer-manager";
 export * from "./color";
+export * from "./constants";
 export * as constants from "./constants";
 export * from "./errors";
 export * from "./fetch";
@@ -58,7 +64,9 @@ export const move = <T>(
       ...array.slice(toIndex, moveIndex),
       ...array.slice(moveIndex + 1, length),
     ];
-  } else if (diff < 0) {
+  }
+
+  if (diff < 0) {
     // move right
     const targetIndex = toIndex + 1;
     return [
@@ -132,383 +140,6 @@ export const meetsFieldType = (
   return false;
 };
 
-export const NONFINITES = new Set(["-inf", "inf", "nan"]);
-
-export const CLASSIFICATION = "Classification";
-export const CLASSIFICATIONS = "Classifications";
-export const DYNAMIC_EMBEDDED_DOCUMENT = "DynamicEmbeddedDocument";
-export const EMBEDDED_DOCUMENT = "EmbeddedDocument";
-export const DETECTION = "Detection";
-export const DETECTIONS = "Detections";
-export const GEOLOCATION = "GeoLocation";
-export const GEOLOCATIONS = "GeoLocations";
-export const HEATMAP = "Heatmap";
-export const KEYPOINT = "Keypoint";
-export const KEYPOINTS = "Keypoints";
-export const PANOPTIC_SEGMENTATION = "PanopticSegmentation";
-export const POLYLINE = "Polyline";
-export const POLYLINES = "Polylines";
-export const REGRESSION = "Regression";
-export const SEGMENTATION = "Segmentation";
-export const TEMPORAL_DETECTION = "TemporalDetection";
-export const TEMPORAL_DETECTIONS = "TemporalDetections";
-
-export const LABEL_LISTS_MAP = {
-  [CLASSIFICATIONS]: "classifications",
-  [DETECTIONS]: "detections",
-  [KEYPOINTS]: "keypoints",
-  [POLYLINES]: "polylines",
-  [TEMPORAL_DETECTIONS]: "detections",
-};
-
-const RESERVED_FIELD_KEYS_MAP = {
-  tags: "tags",
-  filepath: "filepath",
-  sampleID: "sample_id",
-};
-
-export const RESERVED_FIELD_KEYS = Object.values(RESERVED_FIELD_KEYS_MAP);
-
-export const LABELS_MAP = {
-  [CLASSIFICATION]: CLASSIFICATION,
-  [CLASSIFICATIONS]: CLASSIFICATIONS,
-  [DETECTION]: DETECTION,
-  [DETECTIONS]: DETECTIONS,
-  [GEOLOCATION]: GEOLOCATION,
-  [GEOLOCATIONS]: GEOLOCATIONS,
-  [HEATMAP]: HEATMAP,
-  [KEYPOINT]: KEYPOINT,
-  [KEYPOINTS]: KEYPOINTS,
-  [PANOPTIC_SEGMENTATION]: PANOPTIC_SEGMENTATION,
-  [POLYLINE]: POLYLINE,
-  [POLYLINES]: POLYLINES,
-  [SEGMENTATION]: SEGMENTATION,
-  [REGRESSION]: REGRESSION,
-  [TEMPORAL_DETECTION]: TEMPORAL_DETECTION,
-  [TEMPORAL_DETECTIONS]: TEMPORAL_DETECTIONS,
-};
-
-export const MASK_LABELS = new Set([DETECTION, SEGMENTATION]);
-
-// defined as labels that can have on-disk overlays
-export const DENSE_LABELS = new Set([
-  DETECTION,
-  DETECTIONS,
-  HEATMAP,
-  PANOPTIC_SEGMENTATION,
-  SEGMENTATION,
-]);
-
-export const VALID_OBJECT_TYPES = [
-  DETECTION,
-  DETECTIONS,
-  KEYPOINT,
-  KEYPOINTS,
-  POLYLINE,
-  POLYLINES,
-  TEMPORAL_DETECTION,
-  TEMPORAL_DETECTIONS,
-];
-
-export const VALID_CLASS_TYPES = ["Classification", "Classifications"];
-export const VALID_MASK_TYPES = [
-  "Heatmap",
-  "PanopticSegmentation",
-  "Segmentation",
-];
-export const VALID_LIST_TYPES = [
-  "Classifications",
-  "Detections",
-  "Keypoints",
-  "Polylines",
-  "TemporalDetections",
-];
-
-export const VALID_LABEL_TYPES = [
-  ...VALID_CLASS_TYPES,
-  ...VALID_OBJECT_TYPES,
-  ...VALID_MASK_TYPES,
-  "Regression",
-];
-
-export const LABEL_LISTS = [
-  "Classifications",
-  "Detections",
-  "Keypoints",
-  "Polylines",
-  "TemporalDetections",
-];
-
-export const LABEL_LIST = {
-  Classifications: "classifications",
-  Detections: "detections",
-  Keypoints: "keypoints",
-  Polylines: "polylines",
-  TemporalDetections: "detections",
-};
-
-export const LABEL_LIST_PATH = Object.fromEntries(
-  Object.entries(LABEL_LIST).map(([docType, field]) => [
-    withPath(`fiftyone.core.labels`, docType),
-    field,
-  ])
-);
-
-export const NOT_VISIBLE_LIST = [
-  "DictField",
-  "ArrayField",
-  "VectorField",
-  "FrameNumberField",
-];
-
-export const LABEL_DOC_TYPES = VALID_LABEL_TYPES.filter(
-  (label) => !LABEL_LISTS.includes(label)
-);
-
-export const AGGS = {
-  BOUNDS: "Bounds",
-  COUNT: "Count",
-  COUNT_VALUES: "CountValues",
-  DISTINCT: "Distinct",
-};
-
-export const POLYLINE_FIELD = "fiftyone.core.labels.Polyline";
-export const POLYLINES_FIELD = "fiftyone.core.labels.Polylines";
-export const GEO_LOCATIONS_FIELD = "fiftyone.core.labels.GeoLocations";
-export const GEO_LOCATION_FIELD = "fiftyone.core.labels.GeoLocation";
-export const PANOPTIC_SEGMENTATION_FIELD =
-  "fiftyone.core.labels.PanopticSegmentation";
-export const SEGMENTATION_FIELD = "fiftyone.core.labels.Segmentation";
-export const HEATMAP_FIELD = "fiftyone.core.labels.Heatmap";
-export const CLASSIFICATION_FIELD = "fiftyone.core.labels.Classification";
-export const CLASSIFICATIONS_FIELD = "fiftyone.core.labels.Classifications";
-export const DETECTION_FIELD = "fiftyone.core.labels.Detection";
-export const DETECTIONS_FIELD = "fiftyone.core.labels.Detections";
-export const TEMPORAL_DETECTION_FIELD =
-  "fiftyone.core.labels.TemporalDetection";
-export const TEMPORAL_DETECTIONS_FIELD =
-  "fiftyone.core.labels.TemporalDetections";
-export const ARRAY_FIELD = "fiftyone.core.fields.ArrayField";
-export const BOOLEAN_FIELD = "fiftyone.core.fields.BooleanField";
-export const DATE_FIELD = "fiftyone.core.fields.DateField";
-export const DATE_TIME_FIELD = "fiftyone.core.fields.DateTimeField";
-export const DICT_FIELD = "fiftyone.core.fields.DictField";
-export const EMBEDDED_DOCUMENT_FIELD =
-  "fiftyone.core.fields.EmbeddedDocumentField";
-export const DYNAMIC_EMBEDDED_DOCUMENT_FIELD =
-  "fiftyone.core.fields.DynamicEmbeddedDocumentField";
-export const DYNAMIC_EMBEDDED_DOCUMENT_PATH =
-  "fiftyone.core.odm.embedded_document.DynamicEmbeddedDocument";
-export const FLOAT_FIELD = "fiftyone.core.fields.FloatField";
-export const FRAME_NUMBER_FIELD = "fiftyone.core.fields.FrameNumberField";
-export const FRAME_SUPPORT_FIELD = "fiftyone.core.fields.FrameSupportField";
-export const INT_FIELD = "fiftyone.core.fields.IntField";
-export const OBJECT_ID_FIELD = "fiftyone.core.fields.ObjectIdField";
-export const STRING_FIELD = "fiftyone.core.fields.StringField";
-export const LIST_FIELD = "fiftyone.core.fields.ListField";
-export const JUST_FIELD = "fiftyone.core.fields.Field";
-export const VECTOR_FIELD = "fiftyone.core.fields.VectorField";
-export const DETECTION_FILED = "fiftyone.core.labels.Detection";
-export const KEYPOINT_FIELD = "fiftyone.core.labels.Keypoint";
-export const KEYPOINTS_FIELD = "fiftyone.core.labels.Keypoints";
-export const KEYPOINTS_POINTS_FIELD = "fiftyone.core.fields.KeypointsField";
-export const REGRESSION_FIELD = "fiftyone.core.labels.Regression";
-export const GROUP = "fiftyone.core.groups.Group";
-
-export const VALID_LIST_FIELDS = [FRAME_SUPPORT_FIELD, LIST_FIELD];
-
-export const VALID_NON_LIST_LABEL_TYPES = [
-  CLASSIFICATION_FIELD,
-  DETECTION_FIELD,
-  GEO_LOCATION_FIELD,
-  KEYPOINT_FIELD,
-  HEATMAP_FIELD,
-  PANOPTIC_SEGMENTATION_FIELD,
-  POLYLINE_FIELD,
-  REGRESSION_FIELD,
-  SEGMENTATION_FIELD,
-  TEMPORAL_DETECTION_FIELD,
-];
-
-export const VALID_LIST_LABEL_FIELDS = [
-  DETECTIONS_FIELD,
-  CLASSIFICATIONS_FIELD,
-  KEYPOINTS_FIELD,
-  TEMPORAL_DETECTIONS_FIELD,
-  GEO_LOCATIONS_FIELD,
-  POLYLINES_FIELD,
-];
-
-export const DISABLED_LABEL_FIELDS_VISIBILITY = [
-  ...VALID_NON_LIST_LABEL_TYPES,
-  ...VALID_LIST_LABEL_FIELDS,
-];
-
-export const VALID_PRIMITIVE_TYPES = [
-  BOOLEAN_FIELD,
-  DATE_FIELD,
-  DATE_TIME_FIELD,
-  FLOAT_FIELD,
-  FRAME_NUMBER_FIELD,
-  FRAME_SUPPORT_FIELD,
-  INT_FIELD,
-  OBJECT_ID_FIELD,
-  STRING_FIELD,
-];
-
-export const VALID_DISTRIBUTION_TYPES = [
-  BOOLEAN_FIELD,
-  DATE_FIELD,
-  DATE_TIME_FIELD,
-  FLOAT_FIELD,
-  FRAME_NUMBER_FIELD,
-  FRAME_SUPPORT_FIELD,
-  INT_FIELD,
-  STRING_FIELD,
-];
-
-export const VALID_NUMERIC_TYPES = [
-  DATE_FIELD,
-  DATE_TIME_FIELD,
-  FLOAT_FIELD,
-  FRAME_NUMBER_FIELD,
-  FRAME_SUPPORT_FIELD,
-  INT_FIELD,
-];
-
-// list fields may not have a subfield type, so null, undefined is included
-export const UNSUPPORTED_FILTER_TYPES = [
-  ARRAY_FIELD,
-  DICT_FIELD,
-  VECTOR_FIELD,
-  null,
-  undefined,
-];
-
-export const SKIP_FIELD_TYPES = [...UNSUPPORTED_FILTER_TYPES, JUST_FIELD];
-
-export const DYNAMIC_GROUP_FIELDS = [
-  BOOLEAN_FIELD,
-  FLOAT_FIELD,
-  FRAME_NUMBER_FIELD,
-  INT_FIELD,
-  OBJECT_ID_FIELD,
-  STRING_FIELD,
-];
-
-export const LABELS_PATH = "fiftyone.core.labels";
-
-export const PATCHES_FIELDS = withPath(LABELS_PATH, [
-  "Detections",
-  "Polylines",
-]);
-export const CLIPS_SAMPLE_FIELDS = withPath(LABELS_PATH, [
-  "TemporalDetections",
-]);
-export const CLIPS_FRAME_FIELDS = withPath(LABELS_PATH, [
-  "Classifications",
-  "Detections",
-  "Keypoints",
-  "Polylines",
-]);
-
-export const DISABLED_PATHS = ["id", "filepath", "tags", "metadata"];
-
-const BASE_DISABLED_PATHS = ["id", "tags", "label", "confidence"];
-
-export const DETECTION_DISABLED_SUB_PATHS = [
-  ...BASE_DISABLED_PATHS,
-  "bounding_box",
-  "mask",
-  "index",
-];
-
-export const POLYLINE_DISABLED_SUB_PATHS = [
-  ...BASE_DISABLED_PATHS,
-  "points",
-  "closed",
-  "filled",
-  "index",
-];
-
-export const CLASSIFICATION_DISABLED_SUB_PATHS = [
-  ...BASE_DISABLED_PATHS,
-  "logits",
-];
-
-export const REGRESSION_DISABLED_SUB_PATHS = [
-  "id",
-  "tags",
-  "value",
-  "confidence",
-];
-
-export const KEYPOINT_DISABLED_SUB_PATHS = [
-  ...BASE_DISABLED_PATHS,
-  "points",
-  "index",
-];
-
-export const PANOPTIC_SEGMENTATION_DISABLED_SUB_PATHS = [
-  "id",
-  "tags",
-  "mask",
-  "mask_path",
-];
-
-export const SEGMENTATION_DISABLED_SUB_PATHS = [
-  "id",
-  "tags",
-  "mask",
-  "mask_path",
-];
-
-export const HEATMAP_DISABLED_SUB_PATHS = [
-  "id",
-  "tags",
-  "map",
-  "map_path",
-  "range",
-];
-
-export const TEMPORAL_DETECTION_DISABLED_SUB_PATHS = [
-  ...BASE_DISABLED_PATHS,
-  "support",
-];
-
-export const GEOLOCATION_DISABLED_SUB_PATHS = [
-  "id",
-  "tags",
-  "point",
-  "line",
-  "polygon",
-];
-
-export const GEOLOCATIONS_DISABLED_SUB_PATHS = [
-  "id",
-  "tags",
-  "point",
-  "line",
-  "polygons",
-];
-export const BUILT_IN_PANEL_PRIORITY_CONST = 51000;
-
-export function withPath(path: string, types: string): string;
-export function withPath(path: string, types: string[]): string[];
-export function withPath(
-  path: string,
-  types: string | string[]
-): string | string[] {
-  if (Array.isArray(types)) {
-    return types.map((type) => [path, type].join("."));
-  }
-
-  return [path, types].join(".");
-}
-
-export const LABELS = withPath(LABELS_PATH, VALID_LABEL_TYPES);
-export const VALID_KEYPOINTS = withPath(LABELS_PATH, [KEYPOINT, KEYPOINTS]);
-
 export const isNotebook = () => {
   return Boolean(
     typeof window !== "undefined" &&
@@ -571,15 +202,25 @@ export const prettify = (
     }
 
     return v;
-  } else if (typeof v === "number") {
+  }
+
+  if (typeof v === "number") {
     return Number(v.toFixed(3)).toLocaleString();
-  } else if (v === true) {
+  }
+
+  if (v === true) {
     return "True";
-  } else if (v === false) {
+  }
+
+  if (v === false) {
     return "False";
-  } else if ([undefined, null].includes(v)) {
+  }
+
+  if ([undefined, null].includes(v)) {
     return "None";
-  } else if (Array.isArray(v)) {
+  }
+
+  if (Array.isArray(v)) {
     return `[${v.join(", ")}]`;
   }
   return null;
@@ -606,15 +247,15 @@ export const formatDateTime = (timeStamp: number, timeZone: string): string => {
   };
 
   if (!(timeStamp % S)) {
-    delete options.second;
+    options.second = undefined;
   }
 
   if (!(timeStamp % M)) {
-    delete options.minute;
+    options.minute = undefined;
   }
 
   if (!(timeStamp % H)) {
-    delete options.hour;
+    options.hour = undefined;
   }
 
   return new Intl.DateTimeFormat("en-ZA", options)
@@ -691,7 +332,7 @@ export const clone = <T>(data: T): Mutable<T> => {
 };
 
 export const getMimeType = (sample: Sample) => {
-  if (sample.metadata && sample.metadata.mime_type) {
+  if (sample?.metadata?.mime_type) {
     return sample.metadata.mime_type;
   }
 
@@ -715,13 +356,14 @@ export const toSlug = (name: string) => {
   if (name.length < 1) {
     return "";
   }
-  const valid_chars = new RegExp("[a-z0-9._+ -]", "g");
-  const replace_symbols = new RegExp("[-._+ ]+", "g");
-  const trim = new RegExp("-?(?<slug>[0-9a-z][0-9a-z-]*?)-?$");
+  const valid_chars = /[a-z0-9._+ -]/g;
+  const replace_symbols = /[-._+ ]+/g;
+  const trim = /-?(?<slug>[0-9a-z][0-9a-z-]*?)-?$/;
 
   let slug = name.toLowerCase();
   const matches = [];
-  let match;
+  let match = undefined;
+  // biome-ignore lint/suspicious/noAssignInExpressions: useful
   while ((match = valid_chars.exec(slug)) !== null) {
     matches.push(match);
   }
@@ -759,7 +401,7 @@ export function humanReadableBytes(bytes: number): string {
   const k = 1024;
   const i = Math.floor(Math.log(bytes) / Math.log(k));
 
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + units[i];
+  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${units[i]}`;
 }
 
 export enum COLOR_BY {
diff --git a/app/packages/utilities/src/schema.ts b/app/packages/utilities/src/schema.ts
index 188ab1eb37..ed73ffafbb 100644
--- a/app/packages/utilities/src/schema.ts
+++ b/app/packages/utilities/src/schema.ts
@@ -11,6 +11,27 @@ export interface Field {
   pathWithDbField?: string | null;
 }
 
+export type GenericLabel = {
+  [labelKey: string]: {
+    [field: string]: unknown;
+  };
+  // todo: add other label types
+};
+
+export type Sample = {
+  metadata: {
+    width: number;
+    height: number;
+    mime_type?: string;
+  };
+  _id: string;
+  id: string;
+  filepath: string;
+  tags: string[];
+  _label_tags: string[];
+  _media_type: "image" | "video" | "point-cloud" | "3d";
+} & GenericLabel;
+
 export interface StrictField extends Omit<Field, "fields"> {
   fields?: StrictField[];
 }
diff --git a/app/yarn.lock b/app/yarn.lock
index 0cab8b766d..b5ceb8162b 100644
--- a/app/yarn.lock
+++ b/app/yarn.lock
@@ -2103,23 +2103,29 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@fiftyone/looker@workspace:packages/looker"
   dependencies:
+    "@jimp/tiff": ^0.22.12
     "@rollup/plugin-inject": ^5.0.2
     "@types/color-string": ^1.5.0
     "@types/lru-cache": ^7.10.10
+    "@types/utif": ^3.0.5
     "@types/uuid": ^8.3.0
     "@ungap/event-target": ^0.2.2
     "@xmldom/xmldom": ^0.8.6
     buffer: ^6.0.3
     copy-to-clipboard: ^3.3.1
     decode-tiff: ^0.2.1
+    geotiff: ^2.1.3
     immutable: ^4.0.0-rc.12
     lodash: ^4.17.21
     lru-cache: ^11.0.1
     mime: ^2.5.2
     monotone-convex-hull-2d: ^1.0.1
     prettier: ^2.7.1
+    tiff: ^6.1.1
     typescript: ^4.7.4
     typescript-plugin-css-modules: ^5.1.0
+    utif: ^3.1.0
+    utif2: ^4.1.0
     uuid: ^8.3.2
     vite: ^5.2.14
   peerDependencies:
@@ -2637,6 +2643,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@jimp/tiff@npm:^0.22.12":
+  version: 0.22.12
+  resolution: "@jimp/tiff@npm:0.22.12"
+  dependencies:
+    utif2: ^4.0.1
+  peerDependencies:
+    "@jimp/custom": ">=0.3.5"
+  checksum: 1b9995364a91bab7a96ec3c5d5f0ac3de3ecc8950ca9abe2c1d66495bc776446348938117e288cdea1b43210aca5f38dd37cb8ea7e9d70e0a8178b7f81ac73ff
+  languageName: node
+  linkType: hard
+
 "@jridgewell/gen-mapping@npm:^0.3.5":
   version: 0.3.5
   resolution: "@jridgewell/gen-mapping@npm:0.3.5"
@@ -3333,6 +3350,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@petamoriken/float16@npm:^3.4.7":
+  version: 3.9.0
+  resolution: "@petamoriken/float16@npm:3.9.0"
+  checksum: 5242e9e5b630d05a368a0cd9f0b7309d5b9cb12d5ca7d14bf2f761b1c88a65cbfd7e50fb7fd5a7eb4068d310438d5c0ed016748d6c12c244cc7e3d0954113490
+  languageName: node
+  linkType: hard
+
 "@pkgjs/parseargs@npm:^0.11.0":
   version: 0.11.0
   resolution: "@pkgjs/parseargs@npm:0.11.0"
@@ -5248,6 +5272,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/utif@npm:^3.0.5":
+  version: 3.0.5
+  resolution: "@types/utif@npm:3.0.5"
+  dependencies:
+    "@types/node": "*"
+  checksum: dcf759815e1de0cd60849d76f77dc18be172d740fc56af6f57b350874c6b74cdd8ddef09e2af0b3825a0d07c7da8e461af99f20caffe381778fd1d1f2c821105
+  languageName: node
+  linkType: hard
+
 "@types/uuid@npm:^8.3.0":
   version: 8.3.4
   resolution: "@types/uuid@npm:8.3.4"
@@ -9566,6 +9599,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"geotiff@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "geotiff@npm:2.1.3"
+  dependencies:
+    "@petamoriken/float16": ^3.4.7
+    lerc: ^3.0.0
+    pako: ^2.0.4
+    parse-headers: ^2.0.2
+    quick-lru: ^6.1.1
+    web-worker: ^1.2.0
+    xml-utils: ^1.0.2
+    zstddec: ^0.1.0
+  checksum: e966c735339fe121d7cf22fad71c68dbe5f6c88c252baed40bc596c662829bdc6df1c2463855c2dfc5453d191425f6151945b2ad063837cb82a99fe3eb482b50
+  languageName: node
+  linkType: hard
+
 "get-caller-file@npm:^2.0.5":
   version: 2.0.5
   resolution: "get-caller-file@npm:2.0.5"
@@ -10475,6 +10524,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"iobuffer@npm:^5.3.2":
+  version: 5.3.2
+  resolution: "iobuffer@npm:5.3.2"
+  checksum: 9ae2a7dc7ffa8dbb6c6b230a42b028804ba6ee31fbe86d638fdcde941f3c28fc3472659f3fbaa7916357eb78c9512382f73cd4735de01c4f14a0e8cf166ec6ac
+  languageName: node
+  linkType: hard
+
 "ip-address@npm:^9.0.5":
   version: 9.0.5
   resolution: "ip-address@npm:9.0.5"
@@ -11905,6 +11961,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"lerc@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "lerc@npm:3.0.0"
+  checksum: 637699a1359cd80e581bac4bd66dd7ac09e6681fe97346c97939abdbc0170deac1b79ea00a17e334ef5d9d510973ca382abb43c39c8294788dd8391daeb75c32
+  languageName: node
+  linkType: hard
+
 "less@npm:^4.2.0":
   version: 4.2.0
   resolution: "less@npm:4.2.0"
@@ -13707,6 +13770,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"pako@npm:^1.0.11, pako@npm:^1.0.5":
+  version: 1.0.11
+  resolution: "pako@npm:1.0.11"
+  checksum: 1be2bfa1f807608c7538afa15d6f25baa523c30ec870a3228a89579e474a4d992f4293859524e46d5d87fd30fa17c5edf34dbef0671251d9749820b488660b16
+  languageName: node
+  linkType: hard
+
+"pako@npm:^2.0.4, pako@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "pako@npm:2.1.0"
+  checksum: 71666548644c9a4d056bcaba849ca6fd7242c6cf1af0646d3346f3079a1c7f4a66ffec6f7369ee0dc88f61926c10d6ab05da3e1fca44b83551839e89edd75a3e
+  languageName: node
+  linkType: hard
+
 "parent-module@npm:^1.0.0":
   version: 1.0.1
   resolution: "parent-module@npm:1.0.1"
@@ -13737,6 +13814,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"parse-headers@npm:^2.0.2":
+  version: 2.0.5
+  resolution: "parse-headers@npm:2.0.5"
+  checksum: 3e97f01e4c7f960bfbfd0ee489f0bd8d3c72b6c814f1f79b66abec2cca8eaf8e4ecd89deba0b6e61266469aed87350bc932001181c01ff8c29a59e696abe251f
+  languageName: node
+  linkType: hard
+
 "parse-json@npm:^4.0.0":
   version: 4.0.0
   resolution: "parse-json@npm:4.0.0"
@@ -14403,6 +14487,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"quick-lru@npm:^6.1.1":
+  version: 6.1.2
+  resolution: "quick-lru@npm:6.1.2"
+  checksum: 0491a24dcd39b8a325e9d3ae719fad7690a1da7a0dbfa8f16613663dc7d262d08b565005ce16a04497ed4700f1f477b8e06cd46e10a7a112a481a18d056c38f7
+  languageName: node
+  linkType: hard
+
 "quickselect@npm:^2.0.0":
   version: 2.0.0
   resolution: "quickselect@npm:2.0.0"
@@ -16719,6 +16810,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tiff@npm:^6.1.1":
+  version: 6.1.1
+  resolution: "tiff@npm:6.1.1"
+  dependencies:
+    iobuffer: ^5.3.2
+    pako: ^2.1.0
+  checksum: f600d08b0321f87445f03df33e5ac3e687e83b9a6bee3b848d67dc994c395f68273767147c69883531a0f6a28456127fcd5499b488f98758e28d87fbc0d0d0e7
+  languageName: node
+  linkType: hard
+
 "tiny-invariant@npm:1.2.0":
   version: 1.2.0
   resolution: "tiny-invariant@npm:1.2.0"
@@ -17606,6 +17707,24 @@ __metadata:
   languageName: node
   linkType: hard
 
+"utif2@npm:^4.0.1, utif2@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "utif2@npm:4.1.0"
+  dependencies:
+    pako: ^1.0.11
+  checksum: b8a7ba68c503c95dd3137eb20c677553dab7641f4539a75dacc2a94ad7e3d1b5b62b547daa559b07cbeb4b9e2f54c15130ced97667775e320bfdccfba9843edd
+  languageName: node
+  linkType: hard
+
+"utif@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "utif@npm:3.1.0"
+  dependencies:
+    pako: ^1.0.5
+  checksum: 03abe9e04fa50588ae67077ced2e89c869c0c140442a0c5d8cfb559bf587a692a7c92187d49ab1c7e852eae78ff40a298b1325c2461ab7e51c4a0a6ae7ec74e3
+  languageName: node
+  linkType: hard
+
 "util-deprecate@npm:^1.0.2, util-deprecate@npm:~1.0.1":
   version: 1.0.2
   resolution: "util-deprecate@npm:1.0.2"
@@ -17947,6 +18066,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"web-worker@npm:^1.2.0":
+  version: 1.3.0
+  resolution: "web-worker@npm:1.3.0"
+  checksum: ed1f869aefd1d81a43d0fbfe7b315a65beb6d7d2486b378c436a7047eed4216be34b2e6afca738b6fa95d016326b765f5f816355db33267dbf43b2b8a1837c0c
+  languageName: node
+  linkType: hard
+
 "webgl-constants@npm:^1.1.1":
   version: 1.1.1
   resolution: "webgl-constants@npm:1.1.1"
@@ -18189,6 +18315,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"xml-utils@npm:^1.0.2":
+  version: 1.10.1
+  resolution: "xml-utils@npm:1.10.1"
+  checksum: 60a312734f93a98b9c6cc97a9f7d2a14b315ad1528e8c55f44c2d7d0af6eee61255d0aafd6589b41b72fe6e9f6e9727a51c4ab42cfa24f8616724c741cc151ef
+  languageName: node
+  linkType: hard
+
 "xmlchars@npm:^2.2.0":
   version: 2.2.0
   resolution: "xmlchars@npm:2.2.0"
@@ -18274,6 +18407,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"zstddec@npm:^0.1.0":
+  version: 0.1.0
+  resolution: "zstddec@npm:0.1.0"
+  checksum: 76113b43ec4031f9a120285c830e43bafae4c25c0a72f7a9e228af815c3e52432a8414c5d4eb6cfd3282443a4a3d2bc18b445dd702e770b1e330b6e39081750f
+  languageName: node
+  linkType: hard
+
 "zustand@npm:^3.6.9, zustand@npm:^3.7.1":
   version: 3.7.2
   resolution: "zustand@npm:3.7.2"
diff --git a/fiftyone/__public__.py b/fiftyone/__public__.py
index 1ccd9d15a5..139c1c5869 100644
--- a/fiftyone/__public__.py
+++ b/fiftyone/__public__.py
@@ -96,6 +96,7 @@
     Classifications,
     Detection,
     Detections,
+    PanopticSegmentation,
     Polyline,
     Polylines,
     Keypoint,
diff --git a/fiftyone/core/labels.py b/fiftyone/core/labels.py
index b6f0b9d590..8c2d175e28 100644
--- a/fiftyone/core/labels.py
+++ b/fiftyone/core/labels.py
@@ -675,7 +675,7 @@ def to_panoptic_segmentation(
 
         index_map = defaultdict(lambda: 1)
         # pylint: disable=not-an-iterable
-        for detection in self.detections:
+        for idx, detection in enumerate(self.detections):
             if not detection.has_mask:
                 msg = "Skipping detection(s) with no instance mask"
                 warnings.warn(msg)
@@ -691,6 +691,7 @@ def to_panoptic_segmentation(
             _render_instance(mask, detection, target)
 
             index = detection.index
+
             if index is None:
                 index = index_map[detection.label]
                 index_map[detection.label] = index + 1
@@ -1374,6 +1375,18 @@ def transform_mask(self, targets_map, outpath=None, update=False):
 
         return mask
 
+
+class Segmentation(_BaseSegmentation):
+    """A semantic segmentation for an image.
+
+    Provide either the ``mask`` or ``mask_path`` argument to define the
+    segmentation.
+
+    Args:
+        mask (None): a numpy array with integer values encoding the labels
+        mask_path (None): the absolute path to the segmentation image on disk
+    """
+
     def to_detections(
         self,
         mask_targets=None,
@@ -1435,10 +1448,40 @@ def to_detections(
         )
         return Detections(detections=detections)
 
+    def to_panoptic_segmentation(self, mask_types="thing"):
+        """Returns a :class:`PanopticSegmentation` representation of this
+        segmentation.
+
+        Each ``"stuff"`` class will be kept as-is.
+
+        Each ``"thing"`` class will result in one instance per
+        connected region of that class.
+
+        If the mask is 3D, its pixel values will be converted to the
+        integer value of the equivalend hex string.
+
+        Args:
+            mask_types ("thing"): whether the classes are ``"stuff"``
+                (amorphous regions of pixels) or ``"thing"`` (connected
+                regions, each representing an instance of the thing). Can be
+                any of the following:
+
+                -   ``"stuff"`` if all classes are stuff classes
+                -   ``"thing"`` if all classes are thing classes
+                -   a dict mapping pixel values (2D masks) or RGB hex strings
+                    (3D masks) to ``"stuff"`` or ``"thing"`` for each class
+
+        Returns:
+            a :class:`PanopticSegmentation`
+
+        """
+        mask = _mask_to_panoptic(self.get_mask(), mask_types)
+        return PanopticSegmentation(mask=mask)
+
     def to_polylines(
         self,
         mask_targets=None,
-        mask_types=None,
+        mask_types="stuff",
         tolerance=2,
     ):
         """Returns a :class:`Polylines` representation of this instance.
@@ -1454,24 +1497,12 @@ def to_polylines(
                 or RGB hex strings (3D masks) to label strings defining which
                 classes to generate detections for. If omitted, all labels are
                 assigned to their pixel values
-            mask_types (None): whether the classes are ``"stuff"``
-                (amorphous regions of pixels) or ``"thing"`` (connected
-                regions, each representing an instance of the thing). Can be
-                any of the following:
-
+            mask_types ("stuff"):
                 -   ``"stuff"`` if all classes are stuff classes
-                -   ``"thing"`` if all classes are thing classes. Panoptic
-                    instances are handled first, then any remaining labels
-                    are separated into connected components.
-                -   ``"panoptic"`` if all instances are thing classes and all
-                    remaining are stuff classes.
-                -   ``"object"``: only keep panoptic object instances
+                -   ``"thing"`` if all classes are thing classes. Labels are
+                    separated into connected components
                 -   a dict mapping pixel values (2D masks) or RGB hex strings
-                    (3D masks) to ``"stuff"``, ``"thing"``, ``"object"``,
-                    or ``"panoptic"`` for each class
-
-                Defaults to ``"stuff"`` for semantic segmentations and
-                ``"panoptic"`` for panoptic segmentations.
+                    (3D masks) to ``"stuff"`` and ``"thing"``
 
             tolerance (2): a tolerance, in pixels, when generating approximate
                 polylines for each region. Typical values are 1-3 pixels
@@ -1480,70 +1511,106 @@ def to_polylines(
             a :class:`Polylines`
 
         """
-        if mask_types is None:
-            mask_types = (
-                "panoptic"
-                if isinstance(self, PanopticSegmentation)
-                else "stuff"
-            )
-
         polylines = _segmentation_to_polylines(
             self, mask_targets, mask_types, tolerance
         )
         return Polylines(polylines=polylines)
 
 
-class Segmentation(_BaseSegmentation):
-    """A semantic segmentation for an image.
+class PanopticSegmentation(_BaseSegmentation):
+    """A segmentation that encodes both class and instance labels
 
-    Provide either the ``mask`` or ``mask_path`` argument to define the
-    segmentation.
+    The ``mask`` must have at least two channels. The first channel encodes the
+    class, and the second the instance.
 
-    Args:
-        mask (None): a numpy array with integer values encoding the labels
-        mask_path (None): the absolute path to the segmentation image on disk
+    To store a two channel via :attr:`mask_path`, a ".tif" or ".tiff" filepath
+    is required.
     """
 
-    def to_panoptic_segmentation(self, mask_types="thing"):
-        """Returns a :class:`PanopticSegmentation` representation of this
-        segmentation.
-
-        Each ``"stuff"`` class will be kept as-is.
+    def to_detections(
+        self,
+        mask_targets=None,
+        mask_types="panoptic",
+    ):
+        """Returns a :class:`Detections` representation of this instance with
+        instance masks populated.
 
-        Each ``"thing"`` class will result in one instance per
-        connected region of that class.
+        Each ``"stuff"`` class will be converted to a single :class:`Detection`
+        whose instance mask spans all region(s) of the class.
 
-        If the mask is 3D, its pixel values will be converted to the
-        integer value of the equivalend hex string.
+        Each "thing" class is a separate detection. Any pixels with that class
+        but without an instance label are processed according to connected
+        regions.
 
         Args:
-            mask_types ("thing"): whether the classes are ``"stuff"``
-                (amorphous regions of pixels) or ``"thing"`` (connected
-                regions, each representing an instance of the thing). Can be
-                any of the following:
-
-                -   ``"stuff"`` if all classes are stuff classes
-                -   ``"thing"`` if all classes are thing classes
+            mask_targets (None): a dict mapping integer pixel values (2D masks)
+                or RGB hex strings (3D masks) to label strings defining which
+                classes to generate detections for. If omitted, all labels are
+                assigned to their pixel values
+            mask_types ("panoptic"):
+                -   ``"panoptic"`` if all panoptic instances are thing classes
+                     and all remaining are stuff classes
+                -   ``"stuff"`` if all classes are stuff classes. Ignores
+                    panoptic intances
+                -   ``"thing"`` if all classes are thing classes. Panoptic
+                    instances are handled first, then any remaining labels
+                    are separated into connected components
+                -   ``"object"``: only keep panoptic object instances
                 -   a dict mapping pixel values (2D masks) or RGB hex strings
-                    (3D masks) to ``"stuff"`` or ``"thing"`` for each class
+                    (3D masks) to ``"stuff"``, ``"thing"``, ``"panoptic"``,
+                    or ``"object"`` for each class
 
         Returns:
-            a :class:`PanopticSegmentation`
+            a :class:`Detections`
 
         """
-        mask = _mask_to_panoptic(self.get_mask(), mask_types)
-        return PanopticSegmentation(mask=mask)
+        detections = _segmentation_to_detections(
+            self, mask_targets, mask_types
+        )
+        return Detections(detections=detections)
 
+    def to_polylines(
+        self,
+        mask_targets=None,
+        mask_types="panoptic",
+        tolerance=2,
+    ):
+        """Returns a :class:`Polylines` representation of this instance.
 
-class PanopticSegmentation(_BaseSegmentation):
-    """A segmentation that encodes both class and instance labels
+        Each ``"stuff"`` class will be converted to a single :class:`Polyline`
+        that may contain multiple disjoint shapes capturing the class.
 
-    The ``mask`` must have at least two channels. The first channel encodes the
-    class, and the second the instance.
+        Each ``"thing"`` class will result in one :class:`Polyline` instance
+        per connected region of that class.
 
-    To store a two channel via :attr:`mask_path`, a ".tif" or ".tiff" filepath
-    is required.
-    """
+        Args:
+            mask_targets (None): a dict mapping integer pixel values (2D masks)
+                or RGB hex strings (3D masks) to label strings defining which
+                classes to generate detections for. If omitted, all labels are
+                assigned to their pixel values
+            mask_types ("panoptic"):
+                -   ``"panoptic"`` if all instances are thing classes and all
+                    remaining are stuff classes
+                -   ``"stuff"`` if all classes are stuff classes
+                -   ``"thing"`` if all classes are thing classes. Panoptic
+                    instances are handled first, then any remaining labels
+                    are separated into connected components
+                -   ``"object"``: only keep panoptic object instances
+                -   a dict mapping pixel values (2D masks) or RGB hex strings
+                    (3D masks) to ``"stuff"``, ``"thing"``, ``"object"``,
+                    or ``"panoptic"`` for each class
+
+            tolerance (2): a tolerance, in pixels, when generating approximate
+                polylines for each region. Typical values are 1-3 pixels
+
+        Returns:
+            a :class:`Polylines`
+
+        """
+        polylines = _segmentation_to_polylines(
+            self, mask_targets, mask_types, tolerance
+        )
+        return Polylines(polylines=polylines)
 
     def to_segmentation(self, to_rgb=False):
         """Convert panoptic segmentation to semantic segmentation.
@@ -1865,8 +1932,10 @@ def _get_uint_dtype(maxval):
         return np.uint16
     elif maxval < 2**32:
         return np.uint32
+    elif maxval < 2**64:
+        return np.uint64
 
-    raise ValueError(f"max value of {maxval} exceeds upper limit of 2^32")
+    raise ValueError(f"max value of {maxval} exceeds upper limit of 2^64")
 
 
 def _mask_to_image(mask):
@@ -1880,7 +1949,7 @@ def _mask_to_image(mask):
     if not shape_is_valid:
         raise ValueError("unsupported detection mask shape: {mask.shape}")
 
-    allowed_types = (np.uint8, np.uint16, np.uint32, np.uint64, np.int64)
+    allowed_types = (np.uint8, np.uint16, np.uint32, np.uint64)
 
     if mask.dtype not in allowed_types:
         raise ValueError(f"unsupported detection mask dtype: {mask.dtype}")
@@ -1925,7 +1994,8 @@ def _write_mask(mask, mask_path):
     extension = _get_extension(mask_path)
     mask = _mask_to_image(mask)
     if extension in (".tif", ".tiff"):
-        tifffile.imwrite(mask_path, mask, compression="zlib")
+        bigtiff = mask.dtype == np.uint64
+        tifffile.imwrite(mask_path, mask, bigtiff=bigtiff, compression="zlib")
     else:
         if mask.ndim == 3 and mask.shape[-1] == 2:
             # add empty third channel
@@ -2110,7 +2180,7 @@ def _render_polyline(mask, polyline, target, thickness):
 
 def _find_slices(mask):
     """Return slices that tightly bound each unique object in `mask`."""
-    relabeled, forward, backward = sks.relabel_sequential(mask)
+    relabeled, _, backward = sks.relabel_sequential(mask)
     slices = spn.find_objects(relabeled)
     return dict((backward[idx + 1], slc) for idx, slc in enumerate(slices))
 
@@ -2359,10 +2429,6 @@ def _hex_to_rgb(hex_str):
     return (r, g, b)
 
 
-def _rgb_to_hex(rgb):
-    return "#%02x%02x%02x" % tuple(rgb)
-
-
 def _hex_to_int(hex_str):
     r = int(hex_str[1:3], 16)
     g = int(hex_str[3:5], 16)
@@ -2370,13 +2436,6 @@ def _hex_to_int(hex_str):
     return (r << 16) + (g << 8) + b
 
 
-def _int_to_hex(value):
-    r = (value >> 16) & 255
-    g = (value >> 8) & 255
-    b = value & 255
-    return "#%02x%02x%02x" % (r, g, b)
-
-
 def _rgb_array_to_int(mask):
     return (
         np.left_shift(mask[:, :, 0], 16, dtype=int)
@@ -2421,16 +2480,6 @@ def _parse_stuff_instance(mask, offset=None, frame_size=None):
 
 
 def _parse_thing_instances(mask, offset=None, frame_size=None):
-    if offset is None:
-        x_offset, y_offset = (0, 0)
-    else:
-        x_offset, y_offset = offset
-
-    if frame_size is None:
-        height, width = mask.shape
-    else:
-        width, height = frame_size
-
     labeled = skm.label(mask)
     objects = _find_slices(labeled)
     instances = []
diff --git a/tests/unittests/label_tests.py b/tests/unittests/label_tests.py
index e55565c4cd..e3c7aad805 100644
--- a/tests/unittests/label_tests.py
+++ b/tests/unittests/label_tests.py
@@ -5,6 +5,7 @@
 | `voxel51.com <https://voxel51.com/>`_
 |
 """
+
 import unittest
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -34,11 +35,8 @@ def _make_panoptic(dtype=np.uint8):
     class_mask[5:6, 5:6] = max_value
     class_mask[6:7, 6:7] = 1
 
-    panoptic_mask = np.stack([class_mask, instance_mask], axis=-1).astype(
-        dtype
-    )
-    seg = fo.Segmentation(mask=panoptic_mask, is_panoptic=True)
-
+    mask = np.stack([class_mask, instance_mask], axis=-1).astype(dtype)
+    seg = fo.PanopticSegmentation(mask=mask)
     return seg
 
 
@@ -47,7 +45,7 @@ def _make_1d_segmentation(dtype=np.uint8):
     mask = np.zeros((4, 4), dtype=dtype)
     mask[0:2, 0:2] = 1
     mask[2:4, 2:4] = max_value
-    seg = fo.Segmentation(mask=mask, is_panoptic=False)
+    seg = fo.Segmentation(mask=mask)
     return seg
 
 
@@ -56,7 +54,7 @@ def _make_3d_segmentation(dtype=np.uint8):
     mask = np.zeros((4, 4, 3), dtype=dtype)
     mask[0:2, 0:2, 2] = 1
     mask[2:4, 2:4, :] = max_value
-    seg = fo.Segmentation(mask=mask, is_panoptic=False)
+    seg = fo.Segmentation(mask=mask)
     return seg
 
 
@@ -67,6 +65,9 @@ def test_id(self):
             "regression": fo.Regression(value=51),
             "detection": fo.Detection(label="cat", bounding_box=[0, 0, 1, 1]),
             "classification": fo.Classification(label="cat"),
+            "panoptic_segmentation": fo.PanopticSegmentation(
+                mask=np.random.randint(255, size=(4, 4, 2), dtype=np.uint8)
+            ),
             "polyline": fo.Polyline(label="cat", points=[]),
             "keypoint": fo.Keypoint(label="cat", points=[]),
             "segmentation": fo.Segmentation(
@@ -554,7 +555,7 @@ def test_transform_mask(self):
         )
 
         # int to rgb
-        targets_map = dict((i, focl._int_to_hex(i)) for i in range(1, 9))
+        targets_map = dict((i, _int_to_hex(i)) for i in range(1, 9))
         int_to_rgb = focl._transform_mask(mask, targets_map)
         self.assertEqual(int_to_rgb.shape, (3, 3, 3))
         nptest.assert_array_equal(int_to_rgb[:, :, 0], np.zeros_like(mask))
@@ -562,13 +563,13 @@ def test_transform_mask(self):
         nptest.assert_array_equal(int_to_rgb[:, :, 2], mask)
 
         # rgb back to int
-        targets_map = dict((focl._int_to_hex(i), i) for i in range(1, 9))
+        targets_map = dict((_int_to_hex(i), i) for i in range(1, 9))
         rgb_to_int = focl._transform_mask(int_to_rgb, targets_map)
         nptest.assert_array_equal(rgb_to_int, mask)
 
         # rgb to rgb
         targets_map = dict(
-            (focl._int_to_hex(i), focl._int_to_hex(0)) for i in range(1, 9)
+            (_int_to_hex(i), _int_to_hex(0)) for i in range(1, 9)
         )
         rgb_to_rgb = focl._transform_mask(int_to_rgb, targets_map)
         nptest.assert_array_equal(rgb_to_rgb, np.zeros((3, 3, 3), dtype=int))
@@ -582,13 +583,12 @@ def test_panoptic_segmentation_conversion(self):
         )
 
         for mask_types in (
-            None,
             "panoptic",
             "stuff",
             "thing",
             "object",
         ):
-            if mask_types is None or mask_types == "panoptic":
+            if mask_types == "panoptic":
                 n_expected = 5
                 expected_class_mask = seg.mask[..., 0]
             elif mask_types == "stuff":
@@ -607,24 +607,25 @@ def test_panoptic_segmentation_conversion(self):
             self.assertEqual(len(dets.detections), n_expected)
 
             sseg1 = dets.to_segmentation(
-                panoptic=False,
                 frame_size=frame_size,
                 mask_targets=mask_targets,
             )
 
-            pseg1 = dets.to_segmentation(
-                panoptic=True, frame_size=frame_size, mask_targets=mask_targets
+            pseg1 = dets.to_panoptic_segmentation(
+                frame_size=frame_size, mask_targets=mask_targets
             )
 
+            print(pseg1)
+
             self.assertTrue(np.all(sseg1.mask == expected_class_mask))
             self.assertTrue(np.all(pseg1.mask[..., 0] == expected_class_mask))
+            print(np.unique(pseg1.mask[..., 1]))
             self.assertEqual(
                 len(np.unique(pseg1.mask[..., 1])), n_expected + 1
             )
 
             # single detection
-            single_seg1 = dets.detections[0].to_segmentation(
-                panoptic=True,
+            single_seg1 = dets.detections[0].to_panoptic_segmentation(
                 frame_size=frame_size,
             )
 
@@ -633,13 +634,12 @@ def test_panoptic_segmentation_conversion(self):
             self.assertEqual(len(poly.polylines), n_expected)
 
             sseg2 = poly.to_segmentation(
-                panoptic=False,
                 frame_size=frame_size,
                 mask_targets=mask_targets,
             )
 
-            pseg2 = poly.to_segmentation(
-                panoptic=True, frame_size=frame_size, mask_targets=mask_targets
+            pseg2 = poly.to_panoptic_segmentation(
+                frame_size=frame_size, mask_targets=mask_targets
             )
 
             # cannot get the segmentation mask to exactly match the
@@ -651,8 +651,7 @@ def test_panoptic_segmentation_conversion(self):
             )
 
             # single polyline
-            single_seg2 = poly.polylines[0].to_segmentation(
-                panoptic=True,
+            single_seg2 = poly.polylines[0].to_panoptic_segmentation(
                 frame_size=frame_size,
             )
 
@@ -665,9 +664,8 @@ def test_panoptic_segmentation_conversion(self):
     def test_1d_segmentation_conversion(self):
         # 1d to panoptic
         seg = _make_1d_segmentation()
-        pseg = seg.to_panoptic()
+        pseg = seg.to_panoptic_segmentation()
 
-        class_mask = seg.mask
         instance_mask = np.array(
             [[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 2, 2], [0, 0, 2, 2]], dtype=int
         )
@@ -676,7 +674,7 @@ def test_1d_segmentation_conversion(self):
         self.assertTrue(np.all(pseg.mask[..., 1] == instance_mask))
 
         # back to 1d semantic
-        seg2 = pseg.to_semantic()
+        seg2 = pseg.to_segmentation()
         self.assertTrue(np.all(seg2.mask == seg.mask))
 
         # check that this throws an error
@@ -684,7 +682,7 @@ def test_1d_segmentation_conversion(self):
             seg2.to_detections(mask_types="panoptic")
 
         # to rgb semantic
-        seg3 = pseg.to_semantic(to_rgb=True)
+        seg3 = pseg.to_segmentation(to_rgb=True)
         self.assertTrue(np.all(seg3.mask[..., 2] == seg.mask))
         self.assertTrue(np.all(seg3.mask[..., 1] == 0))
         self.assertTrue(np.all(seg3.mask[..., 0] == 0))
@@ -692,7 +690,7 @@ def test_1d_segmentation_conversion(self):
     def test_3d_segmentation_conversion(self):
         # 3d to panoptic
         seg = _make_3d_segmentation()
-        pseg = seg.to_panoptic()
+        pseg = seg.to_panoptic_segmentation()
 
         x = 2**24 - 1
         class_mask = np.array(
@@ -706,10 +704,10 @@ def test_3d_segmentation_conversion(self):
         self.assertTrue(np.all(pseg.mask[..., 0] == class_mask))
         self.assertTrue(np.all(pseg.mask[..., 1] == instance_mask))
 
-        seg2 = pseg.to_semantic(to_rgb=False)
+        seg2 = pseg.to_segmentation(to_rgb=False)
         self.assertTrue(np.all(seg2.mask == class_mask))
 
-        seg3 = pseg.to_semantic(to_rgb=True)
+        seg3 = pseg.to_segmentation(to_rgb=True)
         self.assertTrue(np.all(seg3.mask == seg.mask))
 
     def test_segmentation_io(self):
@@ -730,8 +728,10 @@ def _test_io(dims, tif, dtype):
                     seg = _make_3d_segmentation(dtype=dtype)
                 seg.export_mask(mask_path, update=False)
 
-                seg2 = fo.Segmentation(
-                    mask_path=mask_path, is_panoptic=(dims == 2)
+                seg2 = (
+                    fo.PanopticSegmentation(mask_path=mask_path)
+                    if (dims == 2)
+                    else fo.Segmentation(mask_path=mask_path)
                 )
                 seg2.import_mask()
 
@@ -742,7 +742,7 @@ def _test_io(dims, tif, dtype):
                 if dims == 3:
                     dtypes = [np.uint8]
                 elif tif:
-                    dtypes = [np.uint8, np.uint16, np.uint32, np.uint64]
+                    dtypes = [np.uint8, np.uint16, np.uint32]
                 else:
                     dtypes = [np.uint8, np.uint16]
 
@@ -810,6 +810,13 @@ def test_perform_nms(self):
         self.assertListEqual(ids3, [id2])
 
 
+def _int_to_hex(value):
+    r = (value >> 16) & 255
+    g = (value >> 8) & 255
+    b = value & 255
+    return "#%02x%02x%02x" % (r, g, b)
+
+
 if __name__ == "__main__":
     fo.config.show_progress_bars = False
     unittest.main(verbosity=2)