diff --git a/src/annotation/backend.ts b/src/annotation/backend.ts
index 1c8444e9a1..078d8f5ce3 100644
--- a/src/annotation/backend.ts
+++ b/src/annotation/backend.ts
@@ -33,7 +33,6 @@ import type {
   AnnotationId,
   SerializedAnnotations,
 } from "#src/annotation/index.js";
-import { fixAnnotationAfterStructuredCloning } from "#src/annotation/index.js";
 import type { ChunkManager } from "#src/chunk_manager/backend.js";
 import {
   Chunk,
@@ -67,7 +66,6 @@ import {
 import type { TransformedSource } from "#src/sliceview/base.js";
 import { registerNested, WatchableValue } from "#src/trackable_value.js";
 import type { Borrowed } from "#src/util/disposable.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import {
   getBasePriority,
   getPriorityTier,
@@ -153,7 +151,7 @@ export class AnnotationGeometryChunk extends GeometryChunkMixin(
 
 export class AnnotationSubsetGeometryChunk extends GeometryChunkMixin(Chunk) {
   declare source: AnnotationSubsetGeometryChunkSource;
-  objectId: Uint64;
+  objectId: bigint;
 }
 
 @registerSharedObject(ANNOTATION_METADATA_CHUNK_SOURCE_RPC_ID)
@@ -193,14 +191,14 @@ class AnnotationSubsetGeometryChunkSource extends ChunkSource {
   parent: Borrowed<AnnotationSource> | undefined = undefined;
   declare chunks: Map<string, AnnotationSubsetGeometryChunk>;
   relationshipIndex: number;
-  getChunk(objectId: Uint64) {
+  getChunk(objectId: bigint) {
     const key = getObjectKey(objectId);
     const { chunks } = this;
     let chunk = chunks.get(key);
     if (chunk === undefined) {
       chunk = this.getNewChunk_(AnnotationSubsetGeometryChunk);
       chunk.initialize(key);
-      chunk.objectId = objectId.clone();
+      chunk.objectId = objectId;
       this.addChunk(chunk);
     }
     return chunk;
@@ -303,9 +301,7 @@ registerRPC(ANNOTATION_REFERENCE_DELETE_RPC_ID, function (x: any) {
 registerRPC(ANNOTATION_COMMIT_UPDATE_RPC_ID, function (x: any) {
   const obj = <AnnotationSource>this.get(x.id);
   const annotationId: AnnotationId | undefined = x.annotationId;
-  const newAnnotation: Annotation | null = fixAnnotationAfterStructuredCloning(
-    x.newAnnotation,
-  );
+  const newAnnotation: Annotation | null = x.newAnnotation;
 
   let promise: Promise<Annotation | null>;
   if (annotationId === undefined) {
diff --git a/src/annotation/frontend_source.ts b/src/annotation/frontend_source.ts
index c33e684172..4bde7959b8 100644
--- a/src/annotation/frontend_source.ts
+++ b/src/annotation/frontend_source.ts
@@ -37,7 +37,6 @@ import {
   AnnotationType,
   annotationTypeHandlers,
   annotationTypes,
-  fixAnnotationAfterStructuredCloning,
   makeAnnotationId,
   makeAnnotationPropertySerializers,
 } from "#src/annotation/index.js";
@@ -250,7 +249,7 @@ export class AnnotationMetadataChunk extends Chunk {
   annotation: Annotation | null;
   constructor(source: Borrowed<AnnotationMetadataChunkSource>, x: any) {
     super(source);
-    this.annotation = fixAnnotationAfterStructuredCloning(x.annotation);
+    this.annotation = x.annotation;
   }
 }
 
@@ -1008,8 +1007,7 @@ registerRPC(ANNOTATION_COMMIT_UPDATE_RESULT_RPC_ID, function (x) {
   if (error !== undefined) {
     source.handleFailedUpdate(annotationId, error);
   } else {
-    const newAnnotation: Annotation | null =
-      fixAnnotationAfterStructuredCloning(x.newAnnotation);
+    const newAnnotation: Annotation | null = x.newAnnotation;
     source.handleSuccessfulUpdate(annotationId, newAnnotation);
   }
 });
diff --git a/src/annotation/index.ts b/src/annotation/index.ts
index db2dded24e..b50797935f 100644
--- a/src/annotation/index.ts
+++ b/src/annotation/index.ts
@@ -40,6 +40,7 @@ import {
   expectArray,
   parseArray,
   parseFixedLengthArray,
+  parseUint64,
   verifyEnumString,
   verifyFiniteFloat,
   verifyFiniteNonNegativeFloat,
@@ -54,7 +55,6 @@ import {
 import { parseDataTypeValue } from "#src/util/lerp.js";
 import { getRandomHexString } from "#src/util/random.js";
 import { NullarySignal, Signal } from "#src/util/signal.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 export type AnnotationId = string;
 
@@ -642,7 +642,7 @@ export interface AnnotationBase {
   id: AnnotationId;
   type: AnnotationType;
 
-  relatedSegments?: Uint64[][];
+  relatedSegments?: BigUint64Array[];
   properties: any[];
 }
 
@@ -1017,7 +1017,7 @@ export function annotationToJson(
   const { relatedSegments } = annotation;
   if (relatedSegments?.some((x) => x.length !== 0)) {
     result.segments = relatedSegments.map((segments) =>
-      segments.map((x) => x.toString()),
+      Array.from(segments, (x) => x.toString()),
     );
   }
   if (schema.properties.length !== 0) {
@@ -1053,11 +1053,20 @@ function restoreAnnotation(
       return schema.relationships.map(() => []);
     }
     if (schema.relationships.length === 1 && !Array.isArray(a[0])) {
-      return [parseArray(a, (x) => Uint64.parseString(x))];
+      return [
+        parseFixedLengthArray(new BigUint64Array(a.length), a, parseUint64),
+      ];
     }
     return parseArray(
       expectArray(relObj, schema.relationships.length),
-      (segments) => parseArray(segments, (y) => Uint64.parseString(y)),
+      (segments) => {
+        segments = expectArray(segments);
+        return parseFixedLengthArray(
+          new BigUint64Array(segments.length),
+          segments,
+          parseUint64,
+        );
+      },
     );
   });
   const properties = verifyObjectProperty(obj, "props", (propsObj) => {
@@ -1438,24 +1447,3 @@ export class AnnotationSerializer {
     return serializeAnnotations(this.annotations, this.propertySerializers);
   }
 }
-
-export function fixAnnotationAfterStructuredCloning(obj: Annotation | null) {
-  if (obj == null) {
-    return obj;
-  }
-  const { relatedSegments } = obj;
-  if (relatedSegments !== undefined) {
-    for (
-      let i = 0, numRelationships = relatedSegments.length;
-      i < numRelationships;
-      ++i
-    ) {
-      const segments = relatedSegments[i];
-      if (segments === undefined) continue;
-      relatedSegments[i] = segments.map(
-        (x: { low: number; high: number }) => new Uint64(x.low, x.high),
-      );
-    }
-  }
-  return obj;
-}
diff --git a/src/annotation/renderlayer.ts b/src/annotation/renderlayer.ts
index b0ab74f9e4..dc5d46f082 100644
--- a/src/annotation/renderlayer.ts
+++ b/src/annotation/renderlayer.ts
@@ -126,7 +126,6 @@ import type { MessageList } from "#src/util/message_list.js";
 import { MessageSeverity } from "#src/util/message_list.js";
 import type { AnyConstructor, MixinConstructor } from "#src/util/mixin.js";
 import { NullarySignal } from "#src/util/signal.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import { withSharedVisibility } from "#src/visibility_priority/frontend.js";
 import { GLBuffer } from "#src/webgl/buffer.js";
 import type { ParameterizedContextDependentShaderGetter } from "#src/webgl/dynamic_shader.js";
@@ -639,8 +638,7 @@ function AnnotationRenderLayer<
         pickId = renderContext.pickIDs.register(
           this,
           chunk.numPickIds,
-          0,
-          0,
+          0n,
           chunk,
         );
       }
@@ -701,7 +699,7 @@ function AnnotationRenderLayer<
 
     updateMouseState(
       mouseState: MouseSelectionState,
-      _pickedValue: Uint64,
+      _pickedValue: bigint,
       pickedOffset: number,
       data: any,
     ) {
diff --git a/src/async_computation/encode_compressed_segmentation.ts b/src/async_computation/encode_compressed_segmentation.ts
index 13969cccfe..3d1ee67c83 100644
--- a/src/async_computation/encode_compressed_segmentation.ts
+++ b/src/async_computation/encode_compressed_segmentation.ts
@@ -38,16 +38,7 @@ registerAsyncComputation(
   encodeCompressedSegmentationUint64,
   async (rawData, shape, blockSize) => {
     tempBuffer.clear();
-    encodeChannelsUint64(
-      tempBuffer,
-      blockSize,
-      new BigUint64Array(
-        rawData.buffer,
-        rawData.byteOffset,
-        rawData.length / 2,
-      ),
-      shape,
-    );
+    encodeChannelsUint64(tempBuffer, blockSize, rawData, shape);
     return { value: tempBuffer.view };
   },
 );
diff --git a/src/datasource/brainmaps/backend.ts b/src/datasource/brainmaps/backend.ts
index 51e2de5061..1846c76eab 100644
--- a/src/datasource/brainmaps/backend.ts
+++ b/src/datasource/brainmaps/backend.ts
@@ -84,6 +84,7 @@ import { kInfinityVec, kZeroVec, vec3, vec3Key } from "#src/util/geom.js";
 import {
   parseArray,
   parseFixedLengthArray,
+  parseUint64,
   verifyObject,
   verifyObjectProperty,
   verifyOptionalString,
@@ -91,7 +92,6 @@ import {
   verifyStringArray,
 } from "#src/util/json.js";
 import { defaultStringCompare } from "#src/util/string.js";
-import { Uint64 } from "#src/util/uint64.js";
 import * as vector from "#src/util/vector.js";
 import {
   decodeZIndexCompressed,
@@ -215,13 +215,8 @@ function getFragmentCorner(
   yBits: number,
   zBits: number,
 ): Uint32Array {
-  const id = new Uint64();
-  if (!id.tryParseString(fragmentId, 16)) {
-    throw new Error(
-      `Couldn't parse fragmentId ${fragmentId} as hex-encoded Uint64`,
-    );
-  }
-  return decodeZIndexCompressed(id.toBigInt(), xBits, yBits, zBits);
+  const value = parseUint64(BigInt("0x" + fragmentId));
+  return decodeZIndexCompressed(value, xBits, yBits, zBits);
 }
 
 interface BrainmapsMultiscaleManifestChunk extends MultiscaleManifestChunk {
@@ -383,9 +378,8 @@ function decodeBatchMeshResponse(
     if (index + headerSize > length) {
       throw new Error("Invalid batch mesh fragment response.");
     }
-    const objectIdLow = dataView.getUint32(index, /*littleEndian=*/ true);
-    const objectIdHigh = dataView.getUint32(index + 4, /*littleEndian=*/ true);
-    const objectIdString = new Uint64(objectIdLow, objectIdHigh).toString();
+    const objectId = dataView.getBigUint64(index, /*littleEndian=*/ true);
+    const objectIdString = objectId.toString();
     const prefix = objectIdString + "\0";
     index += 8;
     const fragmentKeyLength = dataView.getUint32(index, /*littleEndian=*/ true);
@@ -892,11 +886,11 @@ function parseBrainmapsAnnotationId(idPrefix: string, fullId: string) {
   return id;
 }
 
-function parseObjectLabels(obj: any): Uint64[][] | undefined {
+function parseObjectLabels(obj: any): BigUint64Array[] | undefined {
   if (obj == null) {
     return undefined;
   }
-  return [parseArray(obj, (x) => Uint64.parseString("" + x, 10))];
+  return [BigUint64Array.from(parseArray(obj, parseUint64))];
 }
 
 function parseAnnotation(
@@ -1064,7 +1058,7 @@ function annotationToBrainmaps(annotation: Annotation): any {
   const objectLabels =
     annotation.relatedSegments === undefined
       ? undefined
-      : annotation.relatedSegments[0].map((x) => x.toString());
+      : Array.from(annotation.relatedSegments[0], (x) => x.toString());
   switch (annotation.type) {
     case AnnotationType.LINE: {
       const { pointA, pointB } = annotation;
diff --git a/src/datasource/graphene/backend.ts b/src/datasource/graphene/backend.ts
index 886a022e0d..b8dec5afb5 100644
--- a/src/datasource/graphene/backend.ts
+++ b/src/datasource/graphene/backend.ts
@@ -65,7 +65,7 @@ import { computeChunkBounds } from "#src/sliceview/volume/backend.js";
 import { Uint64Set } from "#src/uint64_set.js";
 import { vec3, vec3Key } from "#src/util/geom.js";
 import { HttpError } from "#src/util/http_request.js";
-import { Uint64 } from "#src/util/uint64.js";
+import { parseUint64 } from "#src/util/json.js";
 import {
   getBasePriority,
   getPriorityTier,
@@ -136,7 +136,7 @@ export class GrapheneMeshSource extends WithParameters(
     this.parameters.fragmentUrl,
   );
 
-  addNewSegment(segment: Uint64) {
+  addNewSegment(segment: bigint) {
     const { newSegments } = this;
     newSegments.add(segment);
     const TEN_MINUTES = 1000 * 60 * 10;
@@ -196,8 +196,8 @@ export class GrapheneMeshSource extends WithParameters(
 export class ChunkedGraphChunk extends Chunk {
   chunkGridPosition: Float32Array;
   source: GrapheneChunkedGraphChunkSource | null = null;
-  segment: Uint64;
-  leaves: Uint64[] = [];
+  segment: bigint;
+  leaves: BigUint64Array = new BigUint64Array(0);
   chunkDataSize: Uint32Array | null;
 
   initializeVolumeChunk(key: string, chunkGridPosition: Float32Array) {
@@ -208,7 +208,7 @@ export class ChunkedGraphChunk extends Chunk {
   initializeChunkedGraphChunk(
     key: string,
     chunkGridPosition: Float32Array,
-    segment: Uint64,
+    segment: bigint,
   ) {
     this.initializeVolumeChunk(key, chunkGridPosition);
     this.chunkDataSize = null;
@@ -219,7 +219,7 @@ export class ChunkedGraphChunk extends Chunk {
 
   downloadSucceeded() {
     this.systemMemoryBytes = 16; // this.segment
-    this.systemMemoryBytes += 16 * this.leaves.length;
+    this.systemMemoryBytes += this.leaves.byteLength;
     this.queueManager.updateChunkState(this, ChunkState.SYSTEM_MEMORY_WORKER);
     if (this.priorityTier < ChunkPriorityTier.RECENT) {
       this.source!.chunkManager.scheduleUpdateChunkPriorities();
@@ -228,16 +228,12 @@ export class ChunkedGraphChunk extends Chunk {
   }
 
   freeSystemMemory() {
-    this.leaves = [];
+    this.leaves = new BigUint64Array(0);
   }
 }
 
 function decodeChunkedGraphChunk(leaves: string[]) {
-  const final: Uint64[] = new Array(leaves.length);
-  for (let i = 0; i < final.length; ++i) {
-    final[i] = Uint64.parseString(leaves[i]);
-  }
-  return final;
+  return BigUint64Array.from(leaves, parseUint64);
 }
 
 @registerSharedObject()
@@ -290,7 +286,7 @@ export class GrapheneChunkedGraphChunkSource extends WithParameters(
       });
   }
 
-  getChunk(chunkGridPosition: Float32Array, segment: Uint64) {
+  getChunk(chunkGridPosition: Float32Array, segment: bigint) {
     const key = `${vec3Key(chunkGridPosition)}-${segment}`;
     let chunk = <ChunkedGraphChunk>this.chunks.get(key);
 
@@ -442,7 +438,7 @@ export class ChunkedGraphLayer extends withSegmentationLayerBackendState(
 
           forEachVisibleSegment(this, (segment, _) => {
             if (isBaseSegmentId(segment, this.nBitsForLayerId.value)) return; // TODO maybe support highBitRepresentation?
-            const chunk = source.getChunk(curPositionInChunks, segment.clone());
+            const chunk = source.getChunk(curPositionInChunks, segment);
             chunkManager.requestChunk(
               chunk,
               priorityTier,
@@ -460,7 +456,7 @@ export class ChunkedGraphLayer extends withSegmentationLayerBackendState(
   }
 
   private forEachSelectedRootWithLeaves(
-    callback: (rootObjectKey: string, leaves: Uint64[]) => void,
+    callback: (rootObject: bigint, leaves: BigUint64Array) => void,
   ) {
     const { source } = this;
 
@@ -470,7 +466,7 @@ export class ChunkedGraphLayer extends withSegmentationLayerBackendState(
         chunk.priorityTier < ChunkPriorityTier.RECENT
       ) {
         if (this.visibleSegments.has(chunk.segment) && chunk.leaves.length) {
-          callback(chunk.segment.toString(), chunk.leaves);
+          callback(chunk.segment, chunk.leaves);
         }
       }
     }
@@ -481,51 +477,41 @@ export class ChunkedGraphLayer extends withSegmentationLayerBackendState(
   }, 100);
 
   private updateDisplayState() {
-    const visibleLeaves = new Map<string, Uint64Set>();
-    const capacities = new Map<string, number>();
+    const visibleLeaves = new Map<bigint, Uint64Set>();
+    const capacities = new Map<bigint, number>();
 
     // Reserve
-    this.forEachSelectedRootWithLeaves((rootObjectKey, leaves) => {
-      if (!capacities.has(rootObjectKey)) {
-        capacities.set(rootObjectKey, leaves.length);
-      } else {
-        capacities.set(
-          rootObjectKey,
-          capacities.get(rootObjectKey)! + leaves.length,
-        );
-      }
+    this.forEachSelectedRootWithLeaves((rootObject, leaves) => {
+      capacities.set(
+        rootObject,
+        (capacities.get(rootObject) ?? 0) + leaves.length,
+      );
     });
 
     // Collect unique leaves
-    this.forEachSelectedRootWithLeaves((rootObjectKey, leaves) => {
-      if (!visibleLeaves.has(rootObjectKey)) {
-        visibleLeaves.set(rootObjectKey, new Uint64Set());
-        visibleLeaves
-          .get(rootObjectKey)!
-          .reserve(capacities.get(rootObjectKey)!);
-        visibleLeaves
-          .get(rootObjectKey)!
-          .add(Uint64.parseString(rootObjectKey));
+    this.forEachSelectedRootWithLeaves((rootObject, leaves) => {
+      if (!visibleLeaves.has(rootObject)) {
+        visibleLeaves.set(rootObject, new Uint64Set());
+        visibleLeaves.get(rootObject)!.reserve(capacities.get(rootObject)!);
+        visibleLeaves.get(rootObject)!.add(rootObject);
       }
-      visibleLeaves.get(rootObjectKey)!.add(leaves);
+      visibleLeaves.get(rootObject)!.add(leaves);
     });
 
     for (const [root, leaves] of visibleLeaves) {
       // TODO: Delete segments not visible anymore from segmentEquivalences - requires a faster data
       // structure, though.
 
-      /*if (this.segmentEquivalences.has(Uint64.parseString(root))) {
-        this.segmentEquivalences.delete([...this.segmentEquivalences.setElements(Uint64.parseString(root))].filter(x
+      /*if (this.segmentEquivalences.has(root)) {
+        this.segmentEquivalences.delete([...this.segmentEquivalences.setElements(root)].filter(x
       => !leaves.has(x) && !this.visibleSegments.has(x)));
       }*/
       const filteredLeaves = [...leaves].filter(
         (x) => !this.segmentEquivalences.has(x),
       );
 
-      const rootInt = Uint64.parseString(root);
-
       for (const leaf of filteredLeaves) {
-        this.segmentEquivalences.link(rootInt, leaf);
+        this.segmentEquivalences.link(root, leaf);
       }
     }
   }
@@ -553,5 +539,5 @@ registerRPC(CHUNKED_GRAPH_RENDER_LAYER_UPDATE_SOURCES_RPC_ID, function (x) {
 
 registerRPC(GRAPHENE_MESH_NEW_SEGMENT_RPC_ID, function (x) {
   const obj = <GrapheneMeshSource>this.get(x.rpcId);
-  obj.addNewSegment(Uint64.parseString(x.segment));
+  obj.addNewSegment(x.segment);
 });
diff --git a/src/datasource/graphene/base.ts b/src/datasource/graphene/base.ts
index e8ec485731..844cddf352 100644
--- a/src/datasource/graphene/base.ts
+++ b/src/datasource/graphene/base.ts
@@ -29,7 +29,6 @@ import type {
 import { makeSliceViewChunkSpecification } from "#src/sliceview/base.js";
 import type { mat4 } from "#src/util/geom.js";
 import type { FetchOk, HttpError } from "#src/util/http_request.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 export const PYCG_APP_VERSION = 1;
 export const GRAPHENE_MESH_NEW_SEGMENT_RPC_ID = "GrapheneMeshSource:NewSegment";
@@ -71,9 +70,9 @@ export class MultiscaleMeshMetadata {
   sharding: Array<ShardingParameters> | undefined;
 }
 
-export function isBaseSegmentId(segmentId: Uint64, nBitsForLayerId: number) {
-  const layerId = Uint64.rshift(new Uint64(), segmentId, 64 - nBitsForLayerId);
-  return Uint64.equal(layerId, Uint64.ONE);
+export function isBaseSegmentId(segmentId: bigint, nBitsForLayerId: number) {
+  const layerId = segmentId >> BigInt(64 - nBitsForLayerId);
+  return layerId == 1n;
 }
 
 export function getGrapheneFragmentKey(fragmentId: string) {
diff --git a/src/datasource/graphene/frontend.ts b/src/datasource/graphene/frontend.ts
index a0c1669020..d3fc71fa18 100644
--- a/src/datasource/graphene/frontend.ts
+++ b/src/datasource/graphene/frontend.ts
@@ -170,6 +170,7 @@ import { HttpError, isNotFoundError } from "#src/util/http_request.js";
 import {
   parseArray,
   parseFixedLengthArray,
+  parseUint64,
   verify3dVec,
   verifyBoolean,
   verifyEnumString,
@@ -188,7 +189,6 @@ import type { ProgressOptions } from "#src/util/progress_listener.js";
 import { ProgressSpan } from "#src/util/progress_listener.js";
 import { NullarySignal } from "#src/util/signal.js";
 import type { Trackable } from "#src/util/trackable.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { makeDeleteButton } from "#src/widget/delete_button.js";
 import type { DependentViewContext } from "#src/widget/dependent_view_widget.js";
 import { makeIcon } from "#src/widget/icon.js";
@@ -206,9 +206,9 @@ const BLUE_COLOR_SEGMENT = vec4FromVec3(BLUE_COLOR, 0.5);
 const RED_COLOR_HIGHLIGHT = vec4FromVec3(RED_COLOR, 0.25);
 const BLUE_COLOR_HIGHTLIGHT = vec4FromVec3(BLUE_COLOR, 0.25);
 const TRANSPARENT_COLOR = vec4.fromValues(0.5, 0.5, 0.5, 0.01);
-const RED_COLOR_SEGMENT_PACKED = new Uint64(packColor(RED_COLOR_SEGMENT));
-const BLUE_COLOR_SEGMENT_PACKED = new Uint64(packColor(BLUE_COLOR_SEGMENT));
-const TRANSPARENT_COLOR_PACKED = new Uint64(packColor(TRANSPARENT_COLOR));
+const RED_COLOR_SEGMENT_PACKED = BigInt(packColor(RED_COLOR_SEGMENT));
+const BLUE_COLOR_SEGMENT_PACKED = BigInt(packColor(BLUE_COLOR_SEGMENT));
+const TRANSPARENT_COLOR_PACKED = BigInt(packColor(TRANSPARENT_COLOR));
 const MULTICUT_OFF_COLOR = vec4.fromValues(0, 0, 0, 0.5);
 
 class GrapheneMeshSource extends WithParameters(
@@ -787,15 +787,11 @@ function makeColoredAnnotationState(
 }
 
 function getOptionalUint64(obj: any, key: string) {
-  return verifyOptionalObjectProperty(obj, key, (value) =>
-    Uint64.parseString(String(value)),
-  );
+  return verifyOptionalObjectProperty(obj, key, parseUint64);
 }
 
 function getUint64(obj: any, key: string) {
-  return verifyObjectProperty(obj, key, (value) =>
-    Uint64.parseString(String(value)),
-  );
+  return verifyObjectProperty(obj, key, parseUint64);
 }
 
 function restoreSegmentSelection(obj: any): SegmentSelection {
@@ -866,8 +862,8 @@ class GrapheneState implements Trackable {
 }
 
 export interface SegmentSelection {
-  segmentId: Uint64;
-  rootId: Uint64;
+  segmentId: bigint;
+  rootId: bigint;
   position: Float32Array;
   annotationReference?: AnnotationReference;
 }
@@ -893,8 +889,8 @@ class MergeState extends RefCounted implements Trackable {
 
     const segmentSelectionToJSON = (x: SegmentSelection) => {
       return {
-        [SEGMENT_ID_JSON_KEY]: x.segmentId.toJSON(),
-        [ROOT_ID_JSON_KEY]: x.rootId.toJSON(),
+        [SEGMENT_ID_JSON_KEY]: x.segmentId.toString(),
+        [ROOT_ID_JSON_KEY]: x.rootId.toString(),
         [POSITION_JSON_KEY]: [...x.position],
       };
     };
@@ -908,7 +904,7 @@ class MergeState extends RefCounted implements Trackable {
       };
 
       if (x.mergedRoot) {
-        res[MERGED_ROOT_JSON_KEY] = x.mergedRoot.toJSON();
+        res[MERGED_ROOT_JSON_KEY] = x.mergedRoot.toString();
       }
       if (x.error) {
         res[ERROR_JSON_KEY] = x.error;
@@ -969,7 +965,7 @@ class MulticutState extends RefCounted implements Trackable {
   sources = new WatchableSet<SegmentSelection>();
 
   constructor(
-    public focusSegment = new TrackableValue<Uint64 | undefined>(
+    public focusSegment = new TrackableValue<bigint | undefined>(
       undefined,
       (x) => x,
     ),
@@ -1004,14 +1000,14 @@ class MulticutState extends RefCounted implements Trackable {
 
     const segmentSelectionToJSON = (x: SegmentSelection) => {
       return {
-        [SEGMENT_ID_JSON_KEY]: x.segmentId.toJSON(),
-        [ROOT_ID_JSON_KEY]: x.rootId.toJSON(),
+        [SEGMENT_ID_JSON_KEY]: x.segmentId.toString(),
+        [ROOT_ID_JSON_KEY]: x.rootId.toString(),
         [POSITION_JSON_KEY]: [...x.position],
       };
     };
 
     return {
-      [FOCUS_SEGMENT_JSON_KEY]: focusSegment.toJSON(),
+      [FOCUS_SEGMENT_JSON_KEY]: focusSegment.toJSON()?.toString(),
       [SINKS_JSON_KEY]: [...sinks].map(segmentSelectionToJSON),
       [SOURCES_JSON_KEY]: [...sources].map(segmentSelectionToJSON),
     };
@@ -1025,7 +1021,7 @@ class MulticutState extends RefCounted implements Trackable {
     };
 
     verifyOptionalObjectProperty(x, FOCUS_SEGMENT_JSON_KEY, (value) => {
-      this.focusSegment.restoreState(Uint64.parseString(String(value)));
+      this.focusSegment.restoreState(parseUint64(value));
     });
     const sinks = verifyObjectProperty(
       x,
@@ -1062,13 +1058,13 @@ class MulticutState extends RefCounted implements Trackable {
 
   get redSegments() {
     return [...this.sinks]
-      .filter((x) => !Uint64.equal(x.segmentId, x.rootId))
+      .filter((x) => x.segmentId !== x.rootId)
       .map((x) => x.segmentId);
   }
 
   get blueSegments() {
     return [...this.sources]
-      .filter((x) => !Uint64.equal(x.segmentId, x.rootId))
+      .filter((x) => x.segmentId !== x.rootId)
       .map((x) => x.segmentId);
   }
 }
@@ -1086,18 +1082,20 @@ class GraphConnection extends SegmentationGraphSourceConnection {
     super(graph, layer.displayState.segmentationGroupState.value);
     const segmentsState = layer.displayState.segmentationGroupState.value;
     segmentsState.selectedSegments.changed.add(
-      (segmentIds: Uint64[] | Uint64 | null, add: boolean) => {
+      (segmentIds: bigint[] | bigint | null, add: boolean) => {
         if (segmentIds !== null) {
-          segmentIds = Array<Uint64>().concat(segmentIds);
+          segmentIds =
+            typeof segmentIds === "bigint" ? [segmentIds] : segmentIds;
         }
         this.selectedSegmentsChanged(segmentIds, add);
       },
     );
 
     segmentsState.visibleSegments.changed.add(
-      (segmentIds: Uint64[] | Uint64 | null, add: boolean) => {
+      (segmentIds: bigint[] | bigint | null, add: boolean) => {
         if (segmentIds !== null) {
-          segmentIds = Array<Uint64>().concat(segmentIds);
+          segmentIds =
+            typeof segmentIds === "bigint" ? [segmentIds] : segmentIds;
         }
         this.visibleSegmentsChanged(segmentIds, add);
       },
@@ -1150,7 +1148,9 @@ class GraphConnection extends SegmentationGraphSourceConnection {
       mergeAnnotationState.source.childAdded.add((x) => {
         const annotation = x as Line;
         const relatedSegments = annotation.relatedSegments![0];
-        const visibles = relatedSegments.map((x) => visibleSegments.has(x));
+        const visibles = Array.from(relatedSegments, (x) =>
+          visibleSegments.has(x),
+        );
         if (visibles[0] === false) {
           setTimeout(() => {
             const { tool } = layer;
@@ -1179,7 +1179,9 @@ class GraphConnection extends SegmentationGraphSourceConnection {
         const annotation = ref.value as Line | undefined;
         if (annotation) {
           const relatedSegments = annotation.relatedSegments![0];
-          const visibles = relatedSegments.map((x) => visibleSegments.has(x));
+          const visibles = Array.from(relatedSegments, (x) =>
+            visibleSegments.has(x),
+          );
           if (relatedSegments.length < 4) {
             mergeAnnotationState.source.delete(ref);
             StatusMessage.showTemporaryMessage(
@@ -1242,7 +1244,7 @@ class GraphConnection extends SegmentationGraphSourceConnection {
   private lastDeselectionMessage: StatusMessage | undefined;
   private lastDeselectionMessageExists = false;
 
-  private visibleSegmentsChanged(segments: Uint64[] | null, added: boolean) {
+  private visibleSegmentsChanged(segments: bigint[] | null, added: boolean) {
     const { segmentsState } = this;
     const {
       focusSegment: { value: focusSegment },
@@ -1262,9 +1264,7 @@ class GraphConnection extends SegmentationGraphSourceConnection {
       segmentsState.selectedSegments.add(focusSegment);
       segmentsState.visibleSegments.add(focusSegment);
       if (segments) {
-        segments = segments.filter(
-          (segment) => !Uint64.equal(segment, focusSegment),
-        );
+        segments = segments.filter((segment) => segment !== focusSegment);
       }
     }
     if (segments === null) {
@@ -1300,7 +1300,7 @@ class GraphConnection extends SegmentationGraphSourceConnection {
     }
   }
 
-  private selectedSegmentsChanged(segments: Uint64[] | null, added: boolean) {
+  private selectedSegmentsChanged(segments: bigint[] | null, added: boolean) {
     const { segmentsState } = this;
     if (segments === null) {
       const leafSegmentCount = this.segmentsState.selectedSegments.size;
@@ -1315,20 +1315,19 @@ class GraphConnection extends SegmentationGraphSourceConnection {
         segmentId,
         this.graph.info.graph.nBitsForLayerId,
       );
-      const segmentConst = segmentId.clone();
       if (added && isBaseSegment) {
-        this.graph.getRoot(segmentConst).then((rootId) => {
-          if (segmentsState.visibleSegments.has(segmentConst)) {
+        this.graph.getRoot(segmentId).then((rootId) => {
+          if (segmentsState.visibleSegments.has(segmentId)) {
             segmentsState.visibleSegments.add(rootId);
           }
-          segmentsState.selectedSegments.delete(segmentConst);
+          segmentsState.selectedSegments.delete(segmentId);
           segmentsState.selectedSegments.add(rootId);
         });
       }
     }
   }
 
-  computeSplit(include: Uint64, exclude: Uint64): ComputedSplit | undefined {
+  computeSplit(include: bigint, exclude: bigint): ComputedSplit | undefined {
     include;
     exclude;
     return undefined;
@@ -1359,13 +1358,13 @@ class GraphConnection extends SegmentationGraphSourceConnection {
     return undefined;
   }
 
-  meshAddNewSegments(segments: Uint64[]) {
+  meshAddNewSegments(segments: bigint[]) {
     const meshSource = this.getMeshSource();
     if (meshSource) {
       for (const segment of segments) {
         meshSource.rpc!.invoke(GRAPHENE_MESH_NEW_SEGMENT_RPC_ID, {
           rpcId: meshSource.rpcId!,
-          segment: segment.toString(),
+          segment,
         });
       }
     }
@@ -1416,7 +1415,7 @@ class GraphConnection extends SegmentationGraphSourceConnection {
   private submitMerge = async (
     submission: MergeSubmission,
     attempts = 1,
-  ): Promise<Uint64> => {
+  ): Promise<bigint> => {
     this.graph;
     const loadedSubsource = getGraphLoadedSubsource(this.layer)!;
     const annotationToNanometers =
@@ -1439,30 +1438,27 @@ class GraphConnection extends SegmentationGraphSourceConnection {
       }
     }
 
-    return Uint64.ZERO; // appease typescript
+    return 0n; // appease typescript
   };
 
   async bulkMerge(submissions: MergeSubmission[]) {
     const { merges } = this.state.mergeState;
     const bulkMergeHelper = (
       submissions: MergeSubmission[],
-    ): Promise<Uint64[]> => {
+    ): Promise<bigint[]> => {
       return new Promise((f) => {
         if (submissions.length === 0) {
           f([]);
           return;
         }
-        const segmentsToRemove: Uint64[] = [];
-        const replaceSegment = (a: Uint64, b: Uint64) => {
+        const segmentsToRemove: bigint[] = [];
+        const replaceSegment = (a: bigint, b: bigint) => {
           segmentsToRemove.push(a);
           for (const submission of submissions) {
-            if (
-              submission.source &&
-              Uint64.equal(submission.source.rootId, a)
-            ) {
+            if (submission.source && submission.source.rootId === a) {
               submission.source.rootId = b;
             }
-            if (Uint64.equal(submission.sink.rootId, a)) {
+            if (submission.sink.rootId === a) {
               submission.sink.rootId = b;
             }
           }
@@ -1519,7 +1515,7 @@ class GraphConnection extends SegmentationGraphSourceConnection {
 
     submissions = submissions.filter((x) => !x.locked && x.source);
     const segmentsToRemove = await bulkMergeHelper(submissions);
-    const segmentsToAdd: Uint64[] = [];
+    const segmentsToAdd: bigint[] = [];
     for (const submission of submissions) {
       if (submission.error) {
         submission.locked = false;
@@ -1583,7 +1579,7 @@ class GrapheneGraphServerInterface {
     this.httpSource = getHttpSource(sharedKvStoreContext.kvStoreContext, url);
   }
 
-  async getRoot(segment: Uint64, timestamp = "") {
+  async getRoot(segment: bigint, timestamp = "") {
     const timestampEpoch = new Date(timestamp).valueOf() / 1000;
 
     const { fetchOkImpl, baseUrl } = this.httpSource;
@@ -1600,14 +1596,14 @@ class GrapheneGraphServerInterface {
         errorPrefix: "Could not fetch root: ",
       },
     );
-    return Uint64.parseString(jsonResp.root_id);
+    return parseUint64(jsonResp.root_id);
   }
 
   async mergeSegments(
     first: SegmentSelection,
     second: SegmentSelection,
     annotationToNanometers: Float64Array,
-  ): Promise<Uint64> {
+  ): Promise<bigint> {
     const { fetchOkImpl, baseUrl } = this.httpSource;
     const promise = fetchOkImpl(`${baseUrl}/merge?int64_as_str=1`, {
       method: "POST",
@@ -1626,7 +1622,7 @@ class GrapheneGraphServerInterface {
     try {
       const response = await promise;
       const jsonResp = await response.json();
-      return Uint64.parseString(jsonResp.new_root_ids[0]);
+      return parseUint64(jsonResp.new_root_ids[0]);
     } catch (e) {
       if (e instanceof HttpError) {
         const msg = await parseGrapheneError(e);
@@ -1640,7 +1636,7 @@ class GrapheneGraphServerInterface {
     first: SegmentSelection[],
     second: SegmentSelection[],
     annotationToNanometers: Float64Array,
-  ): Promise<Uint64[]> {
+  ): Promise<bigint[]> {
     const { fetchOkImpl, baseUrl } = this.httpSource;
     const promise = fetchOkImpl(`${baseUrl}/split?int64_as_str=1`, {
       method: "POST",
@@ -1661,21 +1657,21 @@ class GrapheneGraphServerInterface {
       errorPrefix: "Split failed: ",
     });
     const jsonResp = await response.json();
-    const final: Uint64[] = new Array(jsonResp.new_root_ids.length);
+    const final: bigint[] = new Array(jsonResp.new_root_ids.length);
     for (let i = 0; i < final.length; ++i) {
-      final[i] = Uint64.parseString(jsonResp.new_root_ids[i]);
+      final[i] = parseUint64(jsonResp.new_root_ids[i]);
     }
     return final;
   }
 
-  async filterLatestRoots(segments: Uint64[]): Promise<Uint64[]> {
+  async filterLatestRoots(segments: bigint[]): Promise<bigint[]> {
     const { fetchOkImpl, baseUrl } = this.httpSource;
     const url = `${baseUrl}/is_latest_roots`;
 
     const promise = fetchOkImpl(url, {
       method: "POST",
       body: JSON.stringify({
-        node_ids: segments.map((x) => x.toJSON()),
+        node_ids: segments.map((x) => x.toString()),
       }),
     });
 
@@ -1686,7 +1682,7 @@ class GrapheneGraphServerInterface {
       },
     );
 
-    const res: Uint64[] = [];
+    const res: bigint[] = [];
     for (const [i, isLatest] of jsonResp.is_latest.entries()) {
       if (isLatest) {
         res.push(segments[i]);
@@ -1737,7 +1733,7 @@ class GrapheneGraphSource extends SegmentationGraphSource {
     );
   }
 
-  getRoot(segment: Uint64) {
+  getRoot(segment: bigint) {
     return this.graphServer.getRoot(segment);
   }
 
@@ -1778,20 +1774,20 @@ class GrapheneGraphSource extends SegmentationGraphSource {
 
   // following not used
 
-  async merge(a: Uint64, b: Uint64): Promise<Uint64> {
+  async merge(a: bigint, b: bigint): Promise<bigint> {
     a;
     b;
-    return new Uint64();
+    return 0n;
   }
 
   async split(
-    include: Uint64,
-    exclude: Uint64,
-  ): Promise<{ include: Uint64; exclude: Uint64 }> {
+    include: bigint,
+    exclude: bigint,
+  ): Promise<{ include: bigint; exclude: bigint }> {
     return { include, exclude };
   }
 
-  trackSegment(id: Uint64, callback: (id: Uint64 | null) => void): () => void {
+  trackSegment(id: bigint, callback: (id: bigint | null) => void): () => void {
     return () => {
       console.log("trackSegment... do nothing", id, callback);
     };
@@ -1998,7 +1994,9 @@ const synchronizeAnnotationSource = (
       point: selection.position,
       type: AnnotationType.POINT,
       properties: [],
-      relatedSegments: [[selection.segmentId, selection.rootId]],
+      relatedSegments: [
+        BigUint64Array.of(selection.segmentId, selection.rootId),
+      ],
     };
     const ref = annotationSource.add(annotation);
     selection.annotationReference = ref;
@@ -2234,21 +2232,21 @@ class MulticutSegmentsTool extends LayerTool<SegmentationUserLayer> {
       const { rootId, segmentId } = currentSegmentSelection;
       const { focusSegment, segments } = multicutState;
       if (focusSegment.value === undefined) {
-        focusSegment.value = rootId.clone();
+        focusSegment.value = rootId;
       }
-      if (!Uint64.equal(focusSegment.value, rootId)) {
+      if (focusSegment.value !== rootId) {
         StatusMessage.showTemporaryMessage(
-          `The selected supervoxel has root segment ${rootId.toString()}, but the supervoxels already selected have root ${focusSegment.value.toString()}`,
+          `The selected supervoxel has root segment ${rootId}, but the supervoxels already selected have root ${focusSegment.value}`,
           12000,
         );
         return;
       }
-      const isRoot = Uint64.equal(rootId, segmentId);
+      const isRoot = rootId === segmentId;
       if (!isRoot) {
         for (const segment of segments) {
-          if (Uint64.equal(segment, segmentId)) {
+          if (segment === segmentId) {
             StatusMessage.showTemporaryMessage(
-              `Supervoxel ${segmentId.toString()} has already been selected`,
+              `Supervoxel ${segmentId} has already been selected`,
               7000,
             );
             return;
@@ -2287,8 +2285,8 @@ const maybeGetSelection = (
   const point = getPoint(layer, mouseState);
   if (point === undefined) return;
   return {
-    rootId: value.clone(),
-    segmentId: baseValue.clone(),
+    rootId: value,
+    segmentId: baseValue,
     position: point,
   };
 };
@@ -2306,7 +2304,7 @@ interface MergeSubmission {
   status?: string;
   sink: SegmentSelection;
   source?: SegmentSelection;
-  mergedRoot?: Uint64;
+  mergedRoot?: bigint;
 }
 
 export class MergeSegmentsPlaceLineTool extends PlaceLineTool {
@@ -2344,15 +2342,15 @@ function lineToSubmission(line: Line, pending: boolean): MergeSubmission {
     locked: false,
     sink: {
       position: line.pointA.slice(),
-      rootId: relatedSegments[0].clone(),
-      segmentId: relatedSegments[1].clone(),
+      rootId: relatedSegments[0],
+      segmentId: relatedSegments[1],
     },
   };
   if (!pending) {
     res.source = {
       position: line.pointB.slice(),
-      rootId: relatedSegments[2].clone(),
-      segmentId: relatedSegments[3].clone(),
+      rootId: relatedSegments[2],
+      segmentId: relatedSegments[3],
     };
   }
   return res;
@@ -2366,12 +2364,12 @@ function mergeToLine(submission: MergeSubmission): Line {
     pointA: sink.position.slice(),
     pointB: source!.position.slice(),
     relatedSegments: [
-      [
-        sink.rootId.clone(),
-        sink.segmentId.clone(),
-        source!.rootId.clone(),
-        source!.segmentId.clone(),
-      ],
+      BigUint64Array.of(
+        sink.rootId,
+        sink.segmentId,
+        source!.rootId,
+        source!.segmentId,
+      ),
     ],
     properties: [],
   };
@@ -2467,7 +2465,7 @@ class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
       return row;
     };
 
-    const createPointElement = (id: Uint64) => {
+    const createPointElement = (id: bigint) => {
       const containerEl = document.createElement("div");
       containerEl.classList.add("graphene-merge-segments-point");
       const widget = makeWidget(augmentSegmentId(this.layer.displayState, id));
diff --git a/src/datasource/nggraph/frontend.ts b/src/datasource/nggraph/frontend.ts
index 8578c9cf6d..76128651a2 100644
--- a/src/datasource/nggraph/frontend.ts
+++ b/src/datasource/nggraph/frontend.ts
@@ -50,6 +50,7 @@ import { DisjointUint64Sets } from "#src/util/disjoint_sets.js";
 import type { RequestInitWithProgress } from "#src/util/http_request.js";
 import {
   parseArray,
+  parseUint64,
   verifyFiniteFloat,
   verifyInt,
   verifyObject,
@@ -57,34 +58,31 @@ import {
   verifyString,
   verifyStringArray,
 } from "#src/util/json.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 const urlPattern = "^(https?://[^/]+)/(.*)$";
 
 interface GraphSegmentInfo {
-  id: Uint64;
-  baseSegments: Uint64[];
-  baseSegmentParents: Uint64[];
+  id: bigint;
+  baseSegments: bigint[];
+  baseSegmentParents: bigint[];
   name: string;
   tags: string[];
   numVoxels: number;
   bounds: number[];
-  lastLogId: Uint64 | null;
+  lastLogId: bigint | null;
 }
 
 function parseGraphSegmentInfo(obj: any): GraphSegmentInfo {
   verifyObject(obj);
   return {
-    id: verifyObjectProperty(obj, "id", (x) =>
-      Uint64.parseString(verifyString(x)),
-    ),
+    id: verifyObjectProperty(obj, "id", parseUint64),
     baseSegments: verifyObjectProperty(obj, "base_segment_ids", (x) =>
-      parseArray(x, (y) => Uint64.parseString(verifyString(y))),
+      parseArray(x, parseUint64),
     ),
     baseSegmentParents: verifyObjectProperty(
       obj,
       "base_segment_parent_ids",
-      (x) => parseArray(x, (y) => Uint64.parseString(verifyString(y))),
+      (x) => parseArray(x, parseUint64),
     ),
     name: verifyObjectProperty(obj, "name", verifyString),
     tags: verifyObjectProperty(obj, "tags", verifyStringArray),
@@ -93,16 +91,13 @@ function parseGraphSegmentInfo(obj: any): GraphSegmentInfo {
       parseArray(x, (y) => verifyFiniteFloat(y)),
     ),
     lastLogId: verifyObjectProperty(obj, "last_log_id", (x) =>
-      x == null ? null : Uint64.parseString(verifyString(x)),
+      x == null ? null : parseUint64(x),
     ),
   };
 }
 
-/// Base-10 string representation of a segment id, used as map key.
-type SegmentIdString = string;
-
 interface ActiveSegmentQuery {
-  id: Uint64;
+  id: bigint;
   current: GraphSegmentInfo | undefined;
   addedEquivalences: boolean;
   seenGeneration: number;
@@ -137,13 +132,12 @@ class GraphConnection extends SegmentationGraphSourceConnection {
     this.visibleSegmentsChanged();
   }
 
-  computeSplit(include: Uint64, exclude: Uint64): ComputedSplit | undefined {
+  computeSplit(include: bigint, exclude: bigint): ComputedSplit | undefined {
     const { segmentEquivalences } = this.segmentsState;
     const graphSegment = segmentEquivalences.get(include);
     if (isBaseSegmentId(graphSegment)) return undefined;
-    if (!Uint64.equal(segmentEquivalences.get(exclude), graphSegment))
-      return undefined;
-    const query = this.segmentQueries.get(graphSegment.toString());
+    if (segmentEquivalences.get(exclude) !== graphSegment) return undefined;
+    const query = this.segmentQueries.get(graphSegment);
     if (query === undefined) return undefined;
     const { current } = query;
     if (current === undefined) return undefined;
@@ -153,27 +147,21 @@ class GraphConnection extends SegmentationGraphSourceConnection {
     for (let i = 0; i < length; ++i) {
       const baseSegment = baseSegments[i];
       const parent = baseSegmentParents[i];
-      if (Uint64.equal(baseSegment, exclude) || Uint64.equal(parent, exclude))
-        continue;
+      if (baseSegment === exclude || parent === exclude) continue;
       ds.link(baseSegment, parent);
       console.log(
-        `Linking ${baseSegment} - ${parent} == ${include}? ${Uint64.equal(
-          include,
-          baseSegment,
-        )} ${Uint64.equal(
-          include,
-          parent,
-        )} :: unioned with include = ${Uint64.equal(
-          include,
-          ds.get(baseSegment),
-        )}, with exclude = ${Uint64.equal(exclude, ds.get(baseSegment))}`,
+        `Linking ${baseSegment} - ${parent} == ${include}? ${
+          include === baseSegment
+        } ${include === parent} :: unioned with include = ${
+          include === ds.get(baseSegment)
+        }, with exclude = ${exclude === ds.get(baseSegment)}`,
       );
     }
-    const includeSegments: Uint64[] = [];
-    const excludeSegments: Uint64[] = [];
+    const includeSegments: bigint[] = [];
+    const excludeSegments: bigint[] = [];
     const includeRep = ds.get(include);
     for (const segment of baseSegments) {
-      if (Uint64.equal(ds.get(segment), includeRep)) {
+      if (ds.get(segment) === includeRep) {
         includeSegments.push(segment);
       } else {
         excludeSegments.push(segment);
@@ -197,7 +185,7 @@ class GraphConnection extends SegmentationGraphSourceConnection {
     debounce(() => this.visibleSegmentsChanged(), 0),
   );
 
-  private segmentQueries = new Map<SegmentIdString, ActiveSegmentQuery>();
+  private segmentQueries = new Map<bigint, ActiveSegmentQuery>();
 
   private ignoreVisibleSegmentsChanged = false;
 
@@ -208,8 +196,7 @@ class GraphConnection extends SegmentationGraphSourceConnection {
       const { segmentQueries } = this;
       const { segmentEquivalences } = this.segmentsState;
       segmentEquivalences.clear();
-      for (const [segmentIdString, query] of segmentQueries) {
-        segmentIdString;
+      for (const [_segmentId, query] of segmentQueries) {
         if (query.current === undefined || isBaseSegmentId(query.id)) continue;
         const { id, baseSegments } = query.current;
         if (baseSegments.length > 0) {
@@ -224,33 +211,27 @@ class GraphConnection extends SegmentationGraphSourceConnection {
     }, 0),
   );
 
-  private registerVisibleSegment(segmentId: Uint64) {
+  private registerVisibleSegment(segmentId: bigint) {
     const query: ActiveSegmentQuery = {
       id: segmentId,
       current: undefined,
       addedEquivalences: false,
       seenGeneration: updateGeneration,
       disposer: this.graph.watchSegment(segmentId, (info) =>
-        this.handleSegmentUpdate(query.id.toString(), info),
+        this.handleSegmentUpdate(query.id, info),
       ),
     };
-    const segmentIdString = segmentId.toString();
-    this.segmentQueries.set(segmentIdString, query);
-    console.log(`adding to segmentQueries: ${segmentIdString}`);
+    this.segmentQueries.set(segmentId, query);
+    console.log(`adding to segmentQueries: ${segmentId}`);
   }
 
-  private handleSegmentUpdate(
-    segmentIdString: SegmentIdString,
-    update: GraphSegmentUpdate,
-  ) {
-    console.log(`handleSegmentUpdate: ${segmentIdString}`);
-    const query = this.segmentQueries.get(segmentIdString)!;
+  private handleSegmentUpdate(segmentId: bigint, update: GraphSegmentUpdate) {
+    console.log(`handleSegmentUpdate: ${segmentId}`);
+    const query = this.segmentQueries.get(segmentId)!;
     if (update === "invalid") {
       query.disposer();
-      console.log(
-        `removing from segmentQueries: ${segmentIdString} due to invalid`,
-      );
-      this.segmentQueries.delete(segmentIdString);
+      console.log(`removing from segmentQueries: ${segmentId} due to invalid`);
+      this.segmentQueries.delete(segmentId);
       try {
         this.ignoreVisibleSegmentsChanged = true;
         this.segmentsState.visibleSegments.delete(query.id);
@@ -270,21 +251,20 @@ class GraphConnection extends SegmentationGraphSourceConnection {
       }
       console.log(
         `Error from ${this.graph.serverUrl}/${this.graph.entityName}` +
-          ` watching segment ${segmentIdString}`,
+          ` watching segment ${segmentId}`,
       );
       return;
     }
     query.current = update;
     const oldId = query.id;
     const newId = update.id;
-    if (!Uint64.equal(newId, oldId)) {
+    if (newId !== oldId) {
       query.id = newId;
-      const newSegmentIdString = newId.toString();
-      const newQuery = this.segmentQueries.get(newSegmentIdString);
+      const newQuery = this.segmentQueries.get(newId);
       console.log(
-        `removing from segmentQueries: ${segmentIdString} due to rename -> ${newId}`,
+        `removing from segmentQueries: ${segmentId} due to rename -> ${newId}`,
       );
-      this.segmentQueries.delete(segmentIdString);
+      this.segmentQueries.delete(segmentId);
       try {
         this.ignoreVisibleSegmentsChanged = true;
         if (this.segmentsState.visibleSegments.has(oldId)) {
@@ -303,14 +283,14 @@ class GraphConnection extends SegmentationGraphSourceConnection {
       }
       if (newQuery === undefined) {
         console.log(`adding to segmentQueries due to rename -> ${newId}`);
-        this.segmentQueries.set(newSegmentIdString, query);
+        this.segmentQueries.set(newId, query);
         this.segmentEquivalencesChanged();
       } else {
         if (
           update.lastLogId !== null &&
           (typeof newQuery.current !== "object" ||
             newQuery.current.lastLogId === null ||
-            Uint64.less(newQuery.current.lastLogId, update.lastLogId))
+            newQuery.current.lastLogId < update.lastLogId)
         ) {
           newQuery.current = update;
           this.segmentEquivalencesChanged();
@@ -330,25 +310,24 @@ class GraphConnection extends SegmentationGraphSourceConnection {
     const { segmentQueries } = this;
     const generation = ++updateGeneration;
     const processVisibleSegments = (visibleSegments: Uint64Set) => {
-      for (const segmentId of visibleSegments.unsafeKeys()) {
-        if (Uint64.equal(segmentId, UNKNOWN_NEW_SEGMENT_ID)) continue;
-        const segmentIdString = segmentId.toString();
-        const existingQuery = segmentQueries.get(segmentIdString);
+      for (const segmentId of visibleSegments.keys()) {
+        if (segmentId === UNKNOWN_NEW_SEGMENT_ID) continue;
+        const existingQuery = segmentQueries.get(segmentId);
         if (existingQuery !== undefined) {
           existingQuery.seenGeneration = generation;
           continue;
         }
-        this.registerVisibleSegment(segmentId.clone());
+        this.registerVisibleSegment(segmentId);
       }
     };
     processVisibleSegments(segmentsState.visibleSegments);
     processVisibleSegments(segmentsState.temporaryVisibleSegments);
-    for (const [segmentIdString, query] of segmentQueries) {
+    for (const [segmentId, query] of segmentQueries) {
       if (query.seenGeneration !== generation) {
         console.log(
-          `removing from segmentQueries due to seenGeneration: ${segmentIdString}`,
+          `removing from segmentQueries due to seenGeneration: ${segmentId}`,
         );
-        segmentQueries.delete(segmentIdString);
+        segmentQueries.delete(segmentId);
         query.disposer();
         if (query.addedEquivalences) {
           this.segmentEquivalencesChanged();
@@ -362,7 +341,7 @@ type GraphSegmentUpdateCallback = (info: GraphSegmentUpdate) => void;
 
 interface WatchInfo {
   callback: GraphSegmentUpdateCallback;
-  segment: Uint64;
+  segment: bigint;
   watchId: number;
 }
 
@@ -491,7 +470,7 @@ export class NggraphSegmentationGraphSource extends SegmentationGraphSource {
     return new GraphConnection(this, segmentsState);
   }
 
-  trackSegment(id: Uint64, callback: (id: Uint64 | null) => void): () => void {
+  trackSegment(id: bigint, callback: (id: bigint | null) => void): () => void {
     return this.watchSegment(id, (info: GraphSegmentUpdate) => {
       if (info === "invalid") {
         callback(null);
@@ -505,7 +484,7 @@ export class NggraphSegmentationGraphSource extends SegmentationGraphSource {
   }
 
   watchSegment(
-    segment: Uint64,
+    segment: bigint,
     callback: GraphSegmentUpdateCallback,
   ): () => void {
     const watchInfo = {
@@ -547,7 +526,7 @@ export class NggraphSegmentationGraphSource extends SegmentationGraphSource {
     return disposer;
   }
 
-  async merge(a: Uint64, b: Uint64): Promise<Uint64> {
+  async merge(a: bigint, b: bigint): Promise<bigint> {
     const response = await nggraphGraphFetch(
       this.chunkManager,
       this.serverUrl,
@@ -562,15 +541,13 @@ export class NggraphSegmentationGraphSource extends SegmentationGraphSource {
       },
     );
     verifyObject(response);
-    return verifyObjectProperty(response, "merged", (x) =>
-      Uint64.parseString(x),
-    );
+    return verifyObjectProperty(response, "merged", parseUint64);
   }
 
   async split(
-    include: Uint64,
-    exclude: Uint64,
-  ): Promise<{ include: Uint64; exclude: Uint64 }> {
+    include: bigint,
+    exclude: bigint,
+  ): Promise<{ include: bigint; exclude: bigint }> {
     const response = await nggraphGraphFetch(
       this.chunkManager,
       this.serverUrl,
@@ -586,12 +563,8 @@ export class NggraphSegmentationGraphSource extends SegmentationGraphSource {
     );
     verifyObject(response);
     return {
-      include: verifyObjectProperty(response, "include", (x) =>
-        Uint64.parseString(x),
-      ),
-      exclude: verifyObjectProperty(response, "exclude", (x) =>
-        Uint64.parseString(x),
-      ),
+      include: verifyObjectProperty(response, "include", parseUint64),
+      exclude: verifyObjectProperty(response, "exclude", parseUint64),
     };
   }
 }
diff --git a/src/datasource/precomputed/backend.ts b/src/datasource/precomputed/backend.ts
index 4bf3912530..a67a996a8a 100644
--- a/src/datasource/precomputed/backend.ts
+++ b/src/datasource/precomputed/backend.ts
@@ -79,7 +79,6 @@ import type { VolumeChunk } from "#src/sliceview/volume/backend.js";
 import { VolumeChunkSource } from "#src/sliceview/volume/backend.js";
 import { convertEndian32, Endianness } from "#src/util/endian.js";
 import { vec3 } from "#src/util/geom.js";
-import { Uint64 } from "#src/util/uint64.js";
 import {
   encodeZIndexCompressed,
   encodeZIndexCompressed3d,
@@ -497,7 +496,7 @@ export class PrecomputedMultiscaleMeshSource extends WithParameters(
     } else {
       ({ response: readResponse, shardInfo: chunk.shardInfo } =
         getOrNotFoundError(
-          await shardedKvStore.readWithShardInfo(chunk.objectId.toBigInt(), {
+          await shardedKvStore.readWithShardInfo(chunk.objectId, {
             signal,
           }),
         ));
@@ -555,7 +554,7 @@ async function fetchByUint64(
     kvStore: KvStoreWithPath;
     shardedKvStore: ShardedKvStore | undefined;
   },
-  id: Uint64,
+  id: bigint,
   signal: AbortSignal,
 ): Promise<ReadResponse | undefined> {
   const { shardedKvStore } = chunkSource;
@@ -565,7 +564,7 @@ async function fetchByUint64(
       signal,
     });
   } else {
-    return shardedKvStore.read(id.toBigInt(), { signal });
+    return shardedKvStore.read(id, { signal });
   }
 }
 
@@ -613,12 +612,11 @@ function parseAnnotations(
     );
   }
   const idOffset = 8 + numBytes * countLow;
-  const id = new Uint64();
   const ids = new Array<string>(countLow);
   for (let i = 0; i < countLow; ++i) {
-    id.low = dv.getUint32(idOffset + i * 8, /*littleEndian=*/ true);
-    id.high = dv.getUint32(idOffset + i * 8 + 4, /*littleEndian=*/ true);
-    ids[i] = id.toString();
+    ids[i] = dv
+      .getBigUint64(idOffset + i * 8, /*littleEndian=*/ true)
+      .toString();
   }
   const geometryData = new AnnotationGeometryData();
   const origData = new Uint8Array(buffer, 8, numBytes * countLow);
@@ -705,7 +703,7 @@ function parseSingleAnnotation(
     (annotation.properties = new Array(parameters.properties.length)),
   );
   let offset = baseNumBytes;
-  const relatedSegments: Uint64[][] = (annotation.relatedSegments = []);
+  const relatedSegments: BigUint64Array[] = (annotation.relatedSegments = []);
   relatedSegments.length = numRelationships;
   for (let i = 0; i < numRelationships; ++i) {
     const count = dv.getUint32(offset, /*littleEndian=*/ true);
@@ -715,12 +713,9 @@ function parseSingleAnnotation(
       );
     }
     offset += 4;
-    const segments: Uint64[] = (relatedSegments[i] = []);
+    const segments = (relatedSegments[i] = new BigUint64Array(count));
     for (let j = 0; j < count; ++j) {
-      segments[j] = new Uint64(
-        dv.getUint32(offset, /*littleEndian=*/ true),
-        dv.getUint32(offset + 4, /*littleEndian=*/ true),
-      );
+      segments[j] = dv.getBigUint64(offset, /*littleEndian=*/ true);
       offset += 8;
     }
   }
@@ -824,7 +819,7 @@ export class PrecomputedAnnotationSourceBackend extends WithParameters(
   }
 
   async downloadMetadata(chunk: AnnotationMetadataChunk, signal: AbortSignal) {
-    const id = Uint64.parseString(chunk.key!);
+    const id = BigInt(chunk.key!);
     const response = await fetchByUint64(this, id, signal);
     if (response === undefined) {
       chunk.annotation = null;
diff --git a/src/datasource/precomputed/frontend.ts b/src/datasource/precomputed/frontend.ts
index 69393aca7e..d5ca9b1bd5 100644
--- a/src/datasource/precomputed/frontend.ts
+++ b/src/datasource/precomputed/frontend.ts
@@ -95,6 +95,7 @@ import {
   MultiscaleVolumeChunkSource,
   VolumeChunkSource,
 } from "#src/sliceview/volume/frontend.js";
+import type { TypedNumberArrayConstructor } from "#src/util/array.js";
 import { transposeNestedArrays } from "#src/util/array.js";
 import { DATA_TYPE_ARRAY_CONSTRUCTOR, DataType } from "#src/util/data_type.js";
 import { mat4, vec3 } from "#src/util/geom.js";
@@ -115,11 +116,11 @@ import {
   verifyString,
   verifyStringArray,
   verifyOptionalBoolean,
+  parseUint64,
 } from "#src/util/json.js";
 import * as matrix from "#src/util/matrix.js";
 import type { ProgressOptions } from "#src/util/progress_listener.js";
 import { ProgressSpan } from "#src/util/progress_listener.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 export class PrecomputedVolumeChunkSource extends WithParameters(
   WithSharedKvStoreContext(VolumeChunkSource),
@@ -1132,21 +1133,16 @@ async function getMeshDataSource(
 
 function parseInlinePropertyMap(data: unknown): InlineSegmentPropertyMap {
   verifyObject(data);
-  const tempUint64 = new Uint64();
   const ids = verifyObjectProperty(data, "ids", (idsObj) => {
     idsObj = verifyStringArray(idsObj);
     const numIds = idsObj.length;
-    const ids = new Uint32Array(numIds * 2);
+    const ids = new BigUint64Array(numIds);
     for (let i = 0; i < numIds; ++i) {
-      if (!tempUint64.tryParseString(idsObj[i])) {
-        throw new Error(`Invalid uint64 id: ${JSON.stringify(idsObj[i])}`);
-      }
-      ids[2 * i] = tempUint64.low;
-      ids[2 * i + 1] = tempUint64.high;
+      ids[i] = parseUint64(idsObj[i]);
     }
     return ids;
   });
-  const numIds = ids.length / 2;
+  const numIds = ids.length;
   const properties = verifyObjectProperty(data, "properties", (propertiesObj) =>
     parseArray(propertiesObj, (propertyObj): InlineSegmentProperty => {
       verifyObject(propertyObj);
@@ -1221,7 +1217,11 @@ function parseInlinePropertyMap(data: unknown): InlineSegmentPropertyMap {
                 `Expected ${numIds} values, but received: ${valuesObj.length}`,
               );
             }
-            return DATA_TYPE_ARRAY_CONSTRUCTOR[dataType].from(valuesObj);
+            return (
+              DATA_TYPE_ARRAY_CONSTRUCTOR[
+                dataType
+              ] as TypedNumberArrayConstructor
+            ).from(valuesObj);
           },
         );
         let min = Infinity;
diff --git a/src/datasource/state_share.ts b/src/datasource/state_share.ts
index 40f48657fc..dc21cc0092 100644
--- a/src/datasource/state_share.ts
+++ b/src/datasource/state_share.ts
@@ -2,6 +2,7 @@ import { ReadableHttpKvStore } from "#src/kvstore/http/common.js";
 import { joinBaseUrlAndPath } from "#src/kvstore/url.js";
 import { StatusMessage } from "#src/status.js";
 import { RefCounted } from "#src/util/disposable.js";
+import { bigintToStringJsonReplacer } from "#src/util/json.js";
 import type { Viewer } from "#src/viewer.js";
 import { makeIcon } from "#src/widget/icon.js";
 
@@ -91,7 +92,10 @@ export class StateShare extends RefCounted {
           .fetchOkImpl(joinBaseUrlAndPath(store.baseUrl, path), {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(viewer.state.toJSON()),
+            body: JSON.stringify(
+              viewer.state.toJSON(),
+              bigintToStringJsonReplacer,
+            ),
           })
           .then((response) => response.json())
           .then((res) => {
diff --git a/src/datasource/zarr/metadata/index.ts b/src/datasource/zarr/metadata/index.ts
index 207fb1a2fb..0cfae9bb96 100644
--- a/src/datasource/zarr/metadata/index.ts
+++ b/src/datasource/zarr/metadata/index.ts
@@ -16,7 +16,6 @@
 
 import type { CodecChainSpec } from "#src/datasource/zarr/codec/index.js";
 import type { DataType } from "#src/util/data_type.js";
-import type { Uint64 } from "#src/util/uint64.js";
 
 export enum ChunkKeyEncoding {
   DEFAULT = 0,
@@ -34,7 +33,7 @@ export interface ArrayMetadata {
   shape: number[];
   chunkShape: number[];
   dataType: DataType;
-  fillValue: number | Uint64;
+  fillValue: number | bigint;
   dimensionNames: (string | null)[];
   dimensionUnits: (string | null)[];
   userAttributes: Record<string, unknown>;
diff --git a/src/gpu_hash/hash_table.benchmark.ts b/src/gpu_hash/hash_table.benchmark.ts
index 3e778fffa4..74cffe1bf9 100644
--- a/src/gpu_hash/hash_table.benchmark.ts
+++ b/src/gpu_hash/hash_table.benchmark.ts
@@ -17,20 +17,16 @@
 import { describe, bench } from "vitest";
 import { HashSetUint64 } from "#src/gpu_hash/hash_table.js";
 import { getRandomValues } from "#src/util/random.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 describe("gpu_hash/hash_table", () => {
   const ht = new HashSetUint64();
   const numValues = 100;
-  const values = new Uint32Array(numValues * 2);
-  const temp = new Uint64();
+  const values = new BigUint64Array(numValues);
   getRandomValues(values);
   bench("insert", () => {
     ht.clear();
-    for (let i = 0, length = values.length; i < length; i += 2) {
-      temp.low = values[i];
-      temp.high = values[i + 1];
-      ht.add(temp);
+    for (const value of values) {
+      ht.add(value);
     }
   });
 });
diff --git a/src/gpu_hash/hash_table.spec.ts b/src/gpu_hash/hash_table.spec.ts
index f567615437..f0bab66855 100644
--- a/src/gpu_hash/hash_table.spec.ts
+++ b/src/gpu_hash/hash_table.spec.ts
@@ -16,22 +16,21 @@
 
 import { describe, it, expect } from "vitest";
 import { HashMapUint64, HashSetUint64 } from "#src/gpu_hash/hash_table.js";
-import { Uint64 } from "#src/util/uint64.js";
+import { randomUint64 } from "#src/util/bigint.js";
 
 describe("gpu_hash/hash_table", () => {
   it("HashSetUint64", () => {
     const ht = new HashSetUint64();
-    const set = new Set<string>();
+    const set = new Set<bigint>();
 
     function compareViaIterate() {
-      const htValues = new Set<string>();
-      for (const v of ht.unsafeKeys()) {
-        const s = v.toString();
-        expect(htValues.has(s), `Duplicate key in hash table: ${s}`).toBe(
+      const htValues = new Set<bigint>();
+      for (const v of ht.keys()) {
+        expect(htValues.has(v), `Duplicate key in hash table: ${v}`).toBe(
           false,
         );
-        expect(set.has(s), `Unexpected key ${s} in hash table`).toBe(true);
-        htValues.add(s);
+        expect(set.has(v), `Unexpected key ${v} in hash table`).toBe(true);
+        htValues.add(v);
       }
       for (const s of set) {
         expect(htValues.has(s), `Hash table is missing key ${s}`).toBe(true);
@@ -40,8 +39,7 @@ describe("gpu_hash/hash_table", () => {
 
     function compareViaHas() {
       for (const s of set) {
-        const k = Uint64.parseString(s);
-        expect(ht.has(k), `Hash table is missing key ${s}`).toBe(true);
+        expect(ht.has(s), `Hash table is missing key ${s}`).toBe(true);
       }
     }
 
@@ -51,70 +49,61 @@ describe("gpu_hash/hash_table", () => {
     }
     const numInsertions = 100;
 
-    function testInsert(k: Uint64) {
-      const s = "" + k;
-      set.add(s);
-      expect(
-        ht.has(k),
-        `Unexpected positive has result for ${[k.low, k.high]}`,
-      ).toBe(false);
+    function testInsert(k: bigint) {
+      set.add(k);
+      expect(ht.has(k), `Unexpected positive has result for ${k}`).toBe(false);
       ht.add(k);
       compare();
     }
 
-    const empty0 = new Uint64(ht.emptyLow, ht.emptyHigh);
+    const empty0 = ht.empty;
     testInsert(empty0);
 
     for (let i = 0; i < numInsertions; ++i) {
-      let k: Uint64;
-      let s: string;
+      let k: bigint;
       while (true) {
-        k = Uint64.random();
-        s = k.toString();
-        if (!set.has(s)) {
+        k = randomUint64();
+        if (!set.has(k)) {
           break;
         }
       }
       testInsert(k);
     }
 
-    const empty1 = new Uint64(ht.emptyLow, ht.emptyHigh);
+    const empty1 = ht.empty;
     testInsert(empty1);
   });
 
   it("HashMapUint64", () => {
     const ht = new HashMapUint64();
-    const map = new Map<string, Uint64>();
+    const map = new Map<bigint, bigint>();
 
     function compareViaIterate() {
-      const htValues = new Map<string, Uint64>();
+      const htValues = new Map<bigint, bigint>();
       for (const [key, value] of ht) {
-        const s = key.toString();
-        expect(htValues.has(s), `Duplicate key in hash table: ${s}`).toBe(
+        expect(htValues.has(key), `Duplicate key in hash table: ${key}`).toBe(
           false,
         );
-        expect(map.has(s), `Unexpected key ${s} in hash table`).toBe(true);
-        htValues.set(s, value.clone());
+        expect(map.has(key), `Unexpected key ${key} in hash table`).toBe(true);
+        htValues.set(key, value);
       }
-      for (const [s, value] of map) {
-        const v = htValues.get(s);
+      for (const [key, value] of map) {
+        const v = htValues.get(key);
         expect(
-          v !== undefined && Uint64.equal(v, value),
-          `Hash table maps ${s} -> ${v} rather than -> ${value}`,
+          v !== undefined && v === value,
+          `Hash table maps ${key} -> ${v} rather than -> ${value}`,
         ).toBe(true);
       }
     }
 
     function compareViaGet() {
-      const value = new Uint64();
-      for (const [s, expectedValue] of map) {
-        const key = Uint64.parseString(s);
-        const has = ht.get(key, value);
+      for (const [key, expectedValue] of map) {
+        const value = ht.get(key);
         expect(
-          has && Uint64.equal(value, expectedValue),
-          `Hash table maps ${key} -> ${has ? value : undefined} ` +
+          value,
+          `Hash table maps ${key} -> ${value} ` +
             `rather than -> ${expectedValue}`,
-        ).toBe(true);
+        ).toEqual(expectedValue);
       }
     }
 
@@ -124,31 +113,28 @@ describe("gpu_hash/hash_table", () => {
     }
     const numInsertions = 100;
 
-    function testInsert(k: Uint64, v: Uint64) {
-      const s = "" + k;
-      map.set(s, v);
-      expect(ht.has(k), `Unexpected positive has result for ${s}`).toBe(false);
+    function testInsert(k: bigint, v: bigint) {
+      map.set(k, v);
+      expect(ht.has(k), `Unexpected positive has result for ${k}`).toBe(false);
       ht.set(k, v);
       compare();
     }
 
-    const empty0 = new Uint64(ht.emptyLow, ht.emptyHigh);
-    testInsert(empty0, Uint64.random());
+    const empty0 = ht.empty;
+    testInsert(empty0, randomUint64());
 
     for (let i = 0; i < numInsertions; ++i) {
-      let k: Uint64;
-      let s: string;
+      let k: bigint;
       while (true) {
-        k = Uint64.random();
-        s = k.toString();
-        if (!map.has(s)) {
+        k = randomUint64();
+        if (!map.has(k)) {
           break;
         }
       }
-      testInsert(k, Uint64.random());
+      testInsert(k, randomUint64());
     }
 
-    const empty1 = new Uint64(ht.emptyLow, ht.emptyHigh);
-    testInsert(empty1, Uint64.random());
+    const empty1 = ht.empty;
+    testInsert(empty1, randomUint64());
   });
 });
diff --git a/src/gpu_hash/hash_table.ts b/src/gpu_hash/hash_table.ts
index 122de83e86..672886aa3a 100644
--- a/src/gpu_hash/hash_table.ts
+++ b/src/gpu_hash/hash_table.ts
@@ -15,8 +15,8 @@
  */
 
 import { hashCombine } from "#src/gpu_hash/hash_function.js";
+import { randomUint64 } from "#src/util/bigint.js";
 import { getRandomValues } from "#src/util/random.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 export const NUM_ALTERNATIVES = 3;
 
@@ -28,30 +28,27 @@ const DEBUG = false;
 
 // Key that needs to be inserted.  Temporary variables used during insert.  These can safely be
 // global because control never leaves functions defined in this module while these are in use.
-let pendingLow = 0;
-let pendingHigh = 0;
-let backupPendingLow = 0;
-let backupPendingHigh = 0;
+let pending = 0n;
+let backupPending = 0n;
 
 export abstract class HashTableBase {
   loadFactor = DEFAULT_LOAD_FACTOR;
   size = 0;
-  table: Uint32Array;
+  table: BigUint64Array;
   tableSize: number;
-  emptyLow = 4294967295;
-  emptyHigh = 4294967295;
+  empty = 0xffffffffffffffffn;
   maxRehashAttempts = 5;
   maxAttempts = 5;
   capacity: number;
 
   /**
-   * Number of uint32 elements per entry in hash table.
+   * Number of uint64 elements per entry in hash table.
    */
   declare entryStride: number;
 
   generation = 0;
 
-  mungedEmptyKey = -1;
+  mungedEmptyKey: bigint | undefined;
 
   constructor(
     public hashSeeds = HashTableBase.generateHashSeeds(NUM_ALTERNATIVES),
@@ -67,35 +64,32 @@ export abstract class HashTableBase {
 
   private updateHashFunctions(numHashes: number) {
     this.hashSeeds = HashTableBase.generateHashSeeds(numHashes);
-    this.mungedEmptyKey = -1;
+    this.mungedEmptyKey = undefined;
   }
 
   /**
    * Invokes callback with a modified version of the hash table data array.
    *
-   * Replaces all slots that appear to be valid entries for (emptyLow, emptyHigh), i.e. slots that
-   * contain (emptyLow, emptyHigh) and to which (emptyLow, emptyHigh) hashes, with (mungedEmptyKey,
-   * mungedEmptyKey).
+   * Replaces all slots that appear to be valid entries for `empty`, i.e. slots that
+   * contain `empty` and to which `empty` hashes, with `mungedEmptyKey`.
    *
-   * mungedEmptyKey is chosen to be a 32-bit value with the property that the 64-bit value
-   * (mungedEmptyKey, mungedEmptyKey) does not hash to any of the same slots as (emptyLow,
-   * emptyHigh).
+   * mungedEmptyKey is chosen such that it does not to any of the same slots as `empty`.
    *
    * This allows the modified data array to be used for lookups without special casing the empty
    * key.
    */
-  tableWithMungedEmptyKey(callback: (table: Uint32Array) => void) {
+  tableWithMungedEmptyKey(callback: (table: BigUint64Array) => void) {
     const numHashes = this.hashSeeds.length;
     const emptySlots = new Array<number>(numHashes);
     for (let i = 0; i < numHashes; ++i) {
-      emptySlots[i] = this.getHash(i, this.emptyLow, this.emptyHigh);
+      emptySlots[i] = this.getHash(i, this.empty);
     }
     let { mungedEmptyKey } = this;
-    if (mungedEmptyKey === -1) {
+    if (mungedEmptyKey === undefined) {
       chooseMungedEmptyKey: while (true) {
-        mungedEmptyKey = (Math.random() * 0x1000000) >>> 0;
+        mungedEmptyKey = randomUint64();
         for (let i = 0; i < numHashes; ++i) {
-          const h = this.getHash(i, mungedEmptyKey, mungedEmptyKey);
+          const h = this.getHash(i, mungedEmptyKey);
           for (let j = 0; j < numHashes; ++j) {
             if (emptySlots[j] === h) {
               continue chooseMungedEmptyKey;
@@ -106,12 +100,11 @@ export abstract class HashTableBase {
         break;
       }
     }
-    const { table, emptyLow, emptyHigh } = this;
+    const { table, empty } = this;
     for (let i = 0; i < numHashes; ++i) {
       const h = emptySlots[i];
-      if (table[h] === emptyLow && table[h + 1] === emptyHigh) {
+      if (table[h] === empty) {
         table[h] = mungedEmptyKey;
-        table[h + 1] = mungedEmptyKey;
       }
     }
     try {
@@ -119,9 +112,8 @@ export abstract class HashTableBase {
     } finally {
       for (let i = 0; i < numHashes; ++i) {
         const h = emptySlots[i];
-        if (table[h] === mungedEmptyKey && table[h + 1] === mungedEmptyKey) {
-          table[h] = emptyLow;
-          table[h + 1] = emptyHigh;
+        if (table[h] === mungedEmptyKey) {
+          table[h] = empty;
         }
       }
     }
@@ -131,71 +123,45 @@ export abstract class HashTableBase {
     return getRandomValues(new Uint32Array(numAlternatives));
   }
 
-  getHash(hashIndex: number, low: number, high: number) {
+  getHash(hashIndex: number, x: bigint) {
     let hash = this.hashSeeds[hashIndex];
-    hash = hashCombine(hash, low);
-    hash = hashCombine(hash, high);
+    hash = hashCombine(hash, Number(x & 0xffffffffn));
+    hash = hashCombine(hash, Number(x >> 32n));
     return this.entryStride * (hash & (this.tableSize - 1));
   }
 
   /**
-   * Iterates over the Uint64 keys contained in the hash set.
-   *
-   * Creates a new Uint64 object at every iteration (otherwise spread and Array.from() fail)
+   * Iterates over the uint64 keys contained in the hash set.
    */
-  *keys(): IterableIterator<Uint64> {
-    const { emptyLow, emptyHigh, entryStride } = this;
+  *keys(): IterableIterator<bigint> {
+    const { empty, entryStride } = this;
     const { table } = this;
     for (let i = 0, length = table.length; i < length; i += entryStride) {
-      const low = table[i];
-      const high = table[i + 1];
-      if (low !== emptyLow || high !== emptyHigh) {
-        yield new Uint64(low, high);
+      const key = table[i];
+      if (key !== empty) {
+        yield key;
       }
     }
   }
 
   /**
-   * Iterates over the Uint64 keys contained in the hash set.
-   *
-   * The same temp value will be modified and yielded at every iteration.
+   * Returns the offset into the hash table of the specified element, or -1 if the element is not
+   * present.
    */
-  *unsafeKeys(temp = new Uint64()): IterableIterator<Uint64> {
-    const { emptyLow, emptyHigh, entryStride } = this;
-    const { table } = this;
-    for (let i = 0, length = table.length; i < length; i += entryStride) {
-      const low = table[i];
-      const high = table[i + 1];
-      if (low !== emptyLow || high !== emptyHigh) {
-        temp.low = low;
-        temp.high = high;
-        yield temp;
-      }
-    }
-  }
-
-  indexOfPair(low: number, high: number) {
-    const { table, emptyLow, emptyHigh } = this;
-    if (low === emptyLow && high === emptyHigh) {
+  indexOf(x: bigint) {
+    const { table, empty } = this;
+    if (x === empty) {
       return -1;
     }
     for (let i = 0, numHashes = this.hashSeeds.length; i < numHashes; ++i) {
-      const h = this.getHash(i, low, high);
-      if (table[h] === low && table[h + 1] === high) {
+      const h = this.getHash(i, x);
+      if (table[h] === x) {
         return h;
       }
     }
     return -1;
   }
 
-  /**
-   * Returns the offset into the hash table of the specified element, or -1 if the element is not
-   * present.
-   */
-  indexOf(x: Uint64) {
-    return this.indexOfPair(x.low, x.high);
-  }
-
   /**
    * Changes the empty key to a value that is not equal to the current empty key and is not present
    * in the table.
@@ -203,29 +169,25 @@ export abstract class HashTableBase {
    * This is called when an attempt is made to insert the empty key.
    */
   private chooseAnotherEmptyKey() {
-    const { emptyLow, emptyHigh, table, entryStride } = this;
-    let newLow: number;
-    let newHigh: number;
+    const { empty, table, entryStride } = this;
+    let newKey: bigint;
     while (true) {
-      newLow = (Math.random() * 0x100000000) >>> 0;
-      newHigh = (Math.random() * 0x100000000) >>> 0;
-      if (newLow === emptyLow && newHigh === emptyHigh) {
+      newKey = randomUint64();
+      if (newKey === empty) {
         continue;
       }
-      if (this.hasPair(newLow, newHigh)) {
+      if (this.has(newKey)) {
         continue;
       }
       break;
     }
 
-    this.emptyLow = newLow;
-    this.emptyHigh = newHigh;
+    this.empty = newKey;
 
     // Replace empty keys in the table.
     for (let h = 0, length = table.length; h < length; h += entryStride) {
-      if (table[h] === emptyLow && table[h + 1] === emptyHigh) {
-        table[h] = newLow;
-        table[h + 1] = newHigh;
+      if (table[h] === empty) {
+        table[h] = newKey;
       }
     }
   }
@@ -233,23 +195,15 @@ export abstract class HashTableBase {
   /**
    * Returns true iff the specified element is present.
    */
-  has(x: Uint64) {
+  has(x: bigint) {
     return this.indexOf(x) !== -1;
   }
 
-  /**
-   * Returns true iff the specified element is present.
-   */
-  hasPair(low: number, high: number) {
-    return this.indexOfPair(low, high) !== -1;
-  }
-
-  delete(x: Uint64) {
+  delete(x: bigint) {
     const index = this.indexOf(x);
     if (index !== -1) {
       const { table } = this;
-      table[index] = this.emptyLow;
-      table[index + 1] = this.emptyHigh;
+      table[index] = this.empty;
       ++this.generation;
       this.size--;
       return true;
@@ -258,13 +212,8 @@ export abstract class HashTableBase {
   }
 
   private clearTable() {
-    const { table, entryStride, emptyLow, emptyHigh } = this;
-    const length = table.length;
-
-    for (let h = 0; h < length; h += entryStride) {
-      table[h] = emptyLow;
-      table[h + 1] = emptyHigh;
-    }
+    const { table, empty } = this;
+    table.fill(empty);
   }
 
   clear() {
@@ -287,42 +236,37 @@ export abstract class HashTableBase {
     return false;
   }
 
-  protected swapPending(table: Uint32Array, offset: number) {
-    const tempLow = pendingLow;
-    const tempHigh = pendingHigh;
+  protected swapPending(table: BigUint64Array, offset: number) {
+    const temp = pending;
     this.storePending(table, offset);
-    table[offset] = tempLow;
-    table[offset + 1] = tempHigh;
+    table[offset] = temp;
   }
 
-  protected storePending(table: Uint32Array, offset: number) {
-    pendingLow = table[offset];
-    pendingHigh = table[offset + 1];
+  protected storePending(table: BigUint64Array, offset: number) {
+    pending = table[offset];
   }
 
   protected backupPending() {
-    backupPendingLow = pendingLow;
-    backupPendingHigh = pendingHigh;
+    backupPending = pending;
   }
 
   protected restorePending() {
-    pendingLow = backupPendingLow;
-    pendingHigh = backupPendingHigh;
+    pending = backupPending;
   }
 
   private tryToInsert() {
     if (DEBUG) {
-      console.log(`tryToInsert: ${pendingLow}, ${pendingHigh}`);
+      console.log(`tryToInsert: ${pending}`);
     }
     let attempt = 0;
-    const { emptyLow, emptyHigh, maxAttempts, table } = this;
+    const { empty, maxAttempts, table } = this;
     const numHashes = this.hashSeeds.length;
 
     let tableIndex = Math.floor(Math.random() * numHashes);
     while (true) {
-      const h = this.getHash(tableIndex, pendingLow, pendingHigh);
+      const h = this.getHash(tableIndex, pending);
       this.swapPending(table, h);
-      if (pendingLow === emptyLow && pendingHigh === emptyHigh) {
+      if (pending === empty) {
         return true;
       }
       if (++attempt === maxAttempts) {
@@ -338,24 +282,23 @@ export abstract class HashTableBase {
   private allocate(tableSize: number) {
     this.tableSize = tableSize;
     const { entryStride } = this;
-    this.table = new Uint32Array(tableSize * entryStride);
+    this.table = new BigUint64Array(tableSize * entryStride);
     this.maxAttempts = tableSize;
     this.clearTable();
     this.capacity = tableSize * this.loadFactor;
-    this.mungedEmptyKey = -1;
+    this.mungedEmptyKey = undefined;
   }
 
-  private rehash(oldTable: Uint32Array, tableSize: number) {
+  private rehash(oldTable: BigUint64Array, tableSize: number) {
     if (DEBUG) {
       console.log("rehash begin");
     }
     this.allocate(tableSize);
     this.updateHashFunctions(this.hashSeeds.length);
-    const { emptyLow, emptyHigh, entryStride } = this;
+    const { empty, entryStride } = this;
     for (let h = 0, length = oldTable.length; h < length; h += entryStride) {
-      const low = oldTable[h];
-      const high = oldTable[h + 1];
-      if (low !== emptyLow || high !== emptyHigh) {
+      const key = oldTable[h];
+      if (key !== empty) {
         this.storePending(oldTable, h);
         if (!this.tryToInsert()) {
           if (DEBUG) {
@@ -400,7 +343,7 @@ export abstract class HashTableBase {
   protected insertInternal() {
     ++this.generation;
 
-    if (pendingLow === this.emptyLow && pendingHigh === this.emptyHigh) {
+    if (pending === this.empty) {
       this.chooseAnotherEmptyKey();
     }
 
@@ -419,136 +362,95 @@ export abstract class HashTableBase {
 }
 
 export class HashSetUint64 extends HashTableBase {
-  add(x: Uint64) {
-    const { low, high } = x;
-    if (this.hasPair(low, high)) {
+  add(x: bigint) {
+    if (this.has(x)) {
       return false;
     }
     if (DEBUG) {
-      console.log(`add: ${low},${high}`);
+      console.log(`add: ${x}`);
     }
-    pendingLow = low;
-    pendingHigh = high;
+    pending = x;
     this.insertInternal();
     return true;
   }
 
   /**
    * Iterates over the keys.
-   * Creates a new Uint64 object at every iteration (otherwise spread and Array.from() fail)
    */
   [Symbol.iterator]() {
-    return this.unsafeKeys();
+    return this.keys();
   }
 }
-HashSetUint64.prototype.entryStride = 2;
+HashSetUint64.prototype.entryStride = 1;
 
 // Value that needs to be inserted.  Temporary variables used during insert.  These can safely be
 // global because control never leaves functions defined in this module while these are in use.
-let pendingValueLow = 0;
-let pendingValueHigh = 0;
-let backupPendingValueLow = 0;
-let backupPendingValueHigh = 0;
+let pendingValue = 0n;
+let backupPendingValue = 0n;
 
 export class HashMapUint64 extends HashTableBase {
-  set(key: Uint64, value: Uint64) {
-    const { low, high } = key;
-    if (this.hasPair(low, high)) {
+  set(key: bigint, value: bigint) {
+    if (this.has(key)) {
       return false;
     }
     if (DEBUG) {
-      console.log(`add: ${low},${high} -> ${value.low},${value.high}`);
+      console.log(`add: ${key} -> ${value}`);
     }
-    pendingLow = low;
-    pendingHigh = high;
-    pendingValueLow = value.low;
-    pendingValueHigh = value.high;
+    pending = key;
+    pendingValue = value;
     this.insertInternal();
     return true;
   }
 
-  get(key: Uint64, value: Uint64): boolean {
+  get(key: bigint): bigint | undefined {
     const h = this.indexOf(key);
     if (h === -1) {
-      return false;
+      return undefined;
     }
-    const { table } = this;
-    value.low = table[h + 2];
-    value.high = table[h + 3];
-    return true;
+    return this.table[h + 1];
   }
 
-  protected swapPending(table: Uint32Array, offset: number) {
-    const tempLow = pendingValueLow;
-    const tempHigh = pendingValueHigh;
+  protected swapPending(table: BigUint64Array, offset: number) {
+    const temp = pendingValue;
     super.swapPending(table, offset);
-    table[offset + 2] = tempLow;
-    table[offset + 3] = tempHigh;
+    table[offset + 1] = temp;
   }
 
-  protected storePending(table: Uint32Array, offset: number) {
+  protected storePending(table: BigUint64Array, offset: number) {
     super.storePending(table, offset);
-    pendingValueLow = table[offset + 2];
-    pendingValueHigh = table[offset + 3];
+    pendingValue = table[offset + 1];
   }
 
   protected backupPending() {
     super.backupPending();
-    backupPendingValueLow = pendingValueLow;
-    backupPendingValueHigh = pendingValueHigh;
+    backupPendingValue = pendingValue;
   }
 
   protected restorePending() {
     super.restorePending();
-    pendingValueLow = backupPendingValueLow;
-    pendingValueHigh = backupPendingValueHigh;
+    pendingValue = backupPendingValue;
   }
 
   /**
-   * Iterates over entries.  The same temporary value will be modified and yielded at every
-   * iteration.
+   * Iterates over entries.
    */
   [Symbol.iterator]() {
-    return this.unsafeEntries();
+    return this.entries();
   }
 
   /**
    * Iterates over entries.
-   * Creates new Uint64 objects at every iteration (otherwise spread and Array.from() fail)
    */
   *entries() {
-    const { emptyLow, emptyHigh, entryStride } = this;
+    const { empty, entryStride } = this;
     const { table } = this;
     for (let i = 0, length = table.length; i < length; i += entryStride) {
-      const low = table[i];
-      const high = table[i + 1];
-      if (low !== emptyLow || high !== emptyHigh) {
-        const key = new Uint64(low, high);
-        const value = new Uint64(table[i + 2], table[i + 3]);
+      const key = table[i];
+      if (key !== empty) {
+        const value = table[i + 1];
         yield [key, value];
       }
     }
   }
-
-  /**
-   * Iterates over entries.  The same temporary value will be modified and yielded at every
-   * iteration.
-   */
-  *unsafeEntries(temp: [Uint64, Uint64] = [new Uint64(), new Uint64()]) {
-    const { emptyLow, emptyHigh, entryStride } = this;
-    const { table } = this;
-    const [key, value] = temp;
-    for (let i = 0, length = table.length; i < length; i += entryStride) {
-      const low = table[i];
-      const high = table[i + 1];
-      if (low !== emptyLow || high !== emptyHigh) {
-        key.low = low;
-        key.high = high;
-        value.low = table[i + 2];
-        value.high = table[i + 3];
-        yield temp;
-      }
-    }
-  }
 }
-HashMapUint64.prototype.entryStride = 4;
+HashMapUint64.prototype.entryStride = 2;
diff --git a/src/gpu_hash/shader.browser_test.ts b/src/gpu_hash/shader.browser_test.ts
index d1fcfa826b..4baad45a94 100644
--- a/src/gpu_hash/shader.browser_test.ts
+++ b/src/gpu_hash/shader.browser_test.ts
@@ -22,9 +22,9 @@ import {
   HashMapShaderManager,
   HashSetShaderManager,
 } from "#src/gpu_hash/shader.js";
+import { randomUint64 } from "#src/util/bigint.js";
 import { DataType } from "#src/util/data_type.js";
 import { getRandomUint32 } from "#src/util/random.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { fragmentShaderTest } from "#src/webgl/shader_testing.js";
 
 const COUNT = 100;
@@ -65,11 +65,14 @@ describe("gpu_hash.shader", () => {
           "outputValue = hashCombine(hashSeed, inputValue);",
         );
         for (let k = 0; k < 20; ++k) {
-          const inputValue = Uint64.random();
+          const inputValue = randomUint64();
           const hashSeed = getRandomUint32();
           tester.execute({ hashSeed, inputValue });
-          let expected = hashCombine(hashSeed, inputValue.low);
-          expected = hashCombine(expected, inputValue.high);
+          let expected = hashCombine(
+            hashSeed,
+            Number(inputValue & 0xffffffffn),
+          );
+          expected = hashCombine(expected, Number(inputValue >> 32n));
           expect(tester.values.outputValue).toEqual(expected);
         }
       },
@@ -91,27 +94,25 @@ describe("gpu_hash.shader", () => {
         const gpuHashTable = tester.registerDisposer(
           GPUHashTable.get(gl, hashTable),
         );
-        const testValues = new Array<Uint64>();
+        const testValues = new Array<bigint>();
         while (testValues.length < COUNT) {
-          const x = Uint64.random();
+          const x = randomUint64();
           if (hashTable.has(x)) {
             continue;
           }
           testValues.push(x);
           hashTable.add(x);
         }
-        const notPresentValues = new Array<Uint64>();
-        notPresentValues.push(
-          new Uint64(hashTable.emptyLow, hashTable.emptyHigh),
-        );
+        const notPresentValues = new Array<bigint>();
+        notPresentValues.push(hashTable.empty);
         while (notPresentValues.length < COUNT) {
-          const x = Uint64.random();
+          const x = randomUint64();
           if (hashTable.has(x)) {
             continue;
           }
           notPresentValues.push(x);
         }
-        function checkPresent(x: Uint64) {
+        function checkPresent(x: bigint) {
           hashTableShaderManager.enable(gl, shader, gpuHashTable);
           tester.execute({ inputValue: x });
           return tester.values.outputValue;
@@ -145,38 +146,33 @@ describe("gpu_hash.shader", () => {
         const gpuHashTable = tester.registerDisposer(
           GPUHashTable.get(gl, hashTable),
         );
-        const testValues = new Array<Uint64>();
+        const testValues = new Array<bigint>();
         while (testValues.length < COUNT) {
-          const x = Uint64.random();
+          const x = randomUint64();
           if (hashTable.has(x)) {
             continue;
           }
           testValues.push(x);
-          hashTable.set(x, Uint64.random());
+          hashTable.set(x, randomUint64());
         }
-        const notPresentValues = new Array<Uint64>();
-        notPresentValues.push(
-          new Uint64(hashTable.emptyLow, hashTable.emptyHigh),
-        );
+        const notPresentValues = new Array<bigint>();
+        notPresentValues.push(hashTable.empty);
         while (notPresentValues.length < COUNT) {
-          const x = Uint64.random();
+          const x = randomUint64();
           if (hashTable.has(x)) {
             continue;
           }
           notPresentValues.push(x);
         }
-        function checkPresent(x: Uint64) {
+        function checkPresent(x: bigint) {
           shaderManager.enable(gl, shader, gpuHashTable);
           tester.execute({ key: x });
           const { values } = tester;
-          const expectedValue = new Uint64();
-          const expectedHas = hashTable.get(x, expectedValue);
+          const value = hashTable.get(x);
           const has = values.isPresent;
-          expect(has, `x=${x}`).toBe(expectedHas);
+          expect(value !== undefined, `x=${x}`).toBe(values.isPresent);
           if (has) {
-            expect(values.outputValue.toString(), `x=${x}`).toBe(
-              expectedValue.toString(),
-            );
+            expect(values.outputValue, `x=${x}`).toBe(value);
           }
         }
         testValues.forEach((x, i) => {
diff --git a/src/kvstore/ocdbt/list_versions.ts b/src/kvstore/ocdbt/list_versions.ts
index 2faf417986..4547e0eadc 100644
--- a/src/kvstore/ocdbt/list_versions.ts
+++ b/src/kvstore/ocdbt/list_versions.ts
@@ -24,12 +24,12 @@ import type {
   VersionQuery,
 } from "#src/kvstore/ocdbt/version_tree.js";
 import {
-  bigintCompare,
   findLeafVersionIndexByLowerBound,
   findVersionNodeIndexByLowerBound,
   findVersionNodeIndexByUpperBound,
   validateVersionTreeNodeReference,
 } from "#src/kvstore/ocdbt/version_tree.js";
+import { bigintCompare } from "#src/util/bigint.js";
 import type { ProgressOptions } from "#src/util/progress_listener.js";
 
 const DEBUG = false;
diff --git a/src/kvstore/ocdbt/version_tree.ts b/src/kvstore/ocdbt/version_tree.ts
index 955687f36f..85c61bf769 100644
--- a/src/kvstore/ocdbt/version_tree.ts
+++ b/src/kvstore/ocdbt/version_tree.ts
@@ -39,6 +39,7 @@ import {
 import type { Config } from "#src/kvstore/ocdbt/manifest.js";
 import type { VersionSpecifier } from "#src/kvstore/ocdbt/version_specifier.js";
 import { binarySearch, binarySearchLowerBound } from "#src/util/array.js";
+import { bigintCompare } from "#src/util/bigint.js";
 
 export type GenerationNumber = bigint;
 export type GenerationIndex = bigint;
@@ -350,10 +351,6 @@ export function compareVersionSpecToVersion(
     : bigintCompare(versionSpec.commitTime, ref.commitTime);
 }
 
-export function bigintCompare(a: bigint, b: bigint) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-
 export function findLeafVersion(
   generationIndex: GenerationIndex,
   versions: BtreeGenerationReference[],
diff --git a/src/layer/index.ts b/src/layer/index.ts
index fea87063da..5c57be7c18 100644
--- a/src/layer/index.ts
+++ b/src/layer/index.ts
@@ -106,7 +106,6 @@ import {
   removeSignalBinding,
 } from "#src/util/signal_binding_updater.js";
 import type { Trackable } from "#src/util/trackable.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { kEmptyFloat32Vec } from "#src/util/vector.js";
 import type { WatchableVisibilityPriority } from "#src/visibility_priority/frontend.js";
 import type { DependentViewContext } from "#src/widget/dependent_view_widget.js";
@@ -1076,7 +1075,7 @@ export class LayerManager extends RefCounted {
 
 export interface PickState {
   pickedRenderLayer: RenderLayer | null;
-  pickedValue: Uint64;
+  pickedValue: bigint;
   pickedOffset: number;
   pickedAnnotationLayer: AnnotationLayerState | undefined;
   pickedAnnotationId: string | undefined;
@@ -1095,7 +1094,7 @@ export class MouseSelectionState implements PickState {
   active = false;
   displayDimensions: DisplayDimensions | undefined = undefined;
   pickedRenderLayer: RenderLayer | null = null;
-  pickedValue = new Uint64(0, 0);
+  pickedValue = 0n;
   pickedOffset = 0;
   pickedAnnotationLayer: AnnotationLayerState | undefined = undefined;
   pickedAnnotationId: string | undefined = undefined;
diff --git a/src/layer/segmentation/index.ts b/src/layer/segmentation/index.ts
index 8551e8c576..f524cf0d7c 100644
--- a/src/layer/segmentation/index.ts
+++ b/src/layer/segmentation/index.ts
@@ -120,13 +120,13 @@ import { RefCounted } from "#src/util/disposable.js";
 import type { vec3, vec4 } from "#src/util/geom.js";
 import {
   parseArray,
+  parseUint64,
   verifyFiniteNonNegativeFloat,
   verifyObjectAsMap,
   verifyOptionalObjectProperty,
   verifyString,
 } from "#src/util/json.js";
 import { Signal } from "#src/util/signal.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { makeWatchableShaderError } from "#src/webgl/dynamic_shader.js";
 import type { DependentViewContext } from "#src/widget/dependent_view_widget.js";
 import { registerLayerShaderControlsTool } from "#src/widget/shader_controls.js";
@@ -221,7 +221,7 @@ export class SegmentationUserLayerGroupState
           if (hidden) {
             stringValue = stringValue.substring(1);
           }
-          const id = Uint64.parseString(stringValue, 10);
+          const id = parseUint64(stringValue);
           const segmentId = segmentEquivalences.get(id);
           selectedSegments.add(segmentId);
           if (!hidden) {
@@ -322,8 +322,8 @@ export class SegmentationUserLayerColorGroupState
           parseRGBColorSpecification(String(x)),
         );
         for (const [idStr, colorVec] of result) {
-          const id = Uint64.parseString(String(idStr));
-          const color = new Uint64(packColor(colorVec));
+          const id = parseUint64(idStr);
+          const color = BigInt(packColor(colorVec));
           this.segmentStatedColors.set(id, color);
         }
       },
@@ -338,8 +338,8 @@ export class SegmentationUserLayerColorGroupState
     const { segmentStatedColors } = this;
     if (segmentStatedColors.size > 0) {
       const j: any = (x[json_keys.SEGMENT_STATED_COLORS_JSON_KEY] = {});
-      for (const [key, value] of segmentStatedColors.unsafeEntries()) {
-        j[key.toString()] = serializeColor(unpackRGB(value.low));
+      for (const [key, value] of segmentStatedColors) {
+        j[key.toString()] = serializeColor(unpackRGB(Number(value)));
       }
     }
     return x;
@@ -534,15 +534,15 @@ class SegmentationUserLayerDisplayState implements SegmentationDisplayState {
   shaderError = makeWatchableShaderError();
   renderScaleHistogram = new RenderScaleHistogram();
   renderScaleTarget = trackableRenderScaleTarget(1);
-  selectSegment: (id: Uint64, pin: boolean | "toggle") => void;
+  selectSegment: (id: bigint, pin: boolean | "toggle") => void;
   transparentPickEnabled: TrackableBoolean;
   baseSegmentColoring = new TrackableBoolean(false, false);
   baseSegmentHighlighting = new TrackableBoolean(false, false);
   useTempSegmentStatedColors2d: SharedWatchableValue<boolean>;
 
-  filterBySegmentLabel: (id: Uint64) => void;
+  filterBySegmentLabel: (id: bigint) => void;
 
-  moveToSegment = (id: Uint64) => {
+  moveToSegment = (id: bigint) => {
     this.layer.moveToSegment(id);
   };
 
@@ -589,18 +589,18 @@ export class SegmentationUserLayer extends Base {
 
   segmentQueryFocusTime = new WatchableValue<number>(Number.NEGATIVE_INFINITY);
 
-  selectSegment = (id: Uint64, pin: boolean | "toggle") => {
+  selectSegment = (id: bigint, pin: boolean | "toggle") => {
     this.manager.root.selectionState.captureSingleLayerState(
       this,
       (state) => {
-        state.value = id.clone();
+        state.value = id;
         return true;
       },
       pin,
     );
   };
 
-  filterBySegmentLabel = (id: Uint64) => {
+  filterBySegmentLabel = (id: bigint) => {
     const augmented = augmentSegmentId(this.displayState, id);
     const { label } = augmented;
     if (!label) return;
@@ -616,8 +616,8 @@ export class SegmentationUserLayer extends Base {
 
   displayState = new SegmentationUserLayerDisplayState(this);
 
-  anchorSegment = new TrackableValue<Uint64 | undefined>(undefined, (x) =>
-    x === undefined ? undefined : Uint64.parseString(x),
+  anchorSegment = new TrackableValue<bigint | undefined>(undefined, (x) =>
+    x === undefined ? undefined : parseUint64(x),
   );
 
   constructor(managedLayer: Borrowed<ManagedUserLayer>) {
@@ -1075,8 +1075,7 @@ export class SegmentationUserLayer extends Base {
     if (value == null) {
       return value;
     }
-    // Must copy, because `value` may be a temporary Uint64 returned by PickIDManager.
-    return maybeAugmentSegmentId(this.displayState, value, /*mustCopy=*/ true);
+    return maybeAugmentSegmentId(this.displayState, value);
   }
 
   handleAction(action: string, context: SegmentationActionContext) {
@@ -1120,13 +1119,12 @@ export class SegmentationUserLayer extends Base {
   }
   selectionStateFromJson(state: this["selectionState"], json: any) {
     super.selectionStateFromJson(state, json);
-    const v = new Uint64();
     let { value } = state;
     if (typeof value === "number") value = value.toString();
-    if (typeof value !== "string" || !v.tryParseString(value)) {
+    try {
+      state.value = parseUint64(value);
+    } catch {
       state.value = undefined;
-    } else {
-      state.value = v;
     }
   }
   selectionStateToJson(state: this["selectionState"], forPython: boolean): any {
@@ -1142,7 +1140,7 @@ export class SegmentationUserLayer extends Base {
       } else {
         json.value = (value.value || value.key).toString();
       }
-    } else if (value instanceof Uint64) {
+    } else if (typeof value === "bigint") {
       json.value = value.toString();
     }
     return json;
@@ -1154,15 +1152,18 @@ export class SegmentationUserLayer extends Base {
     context: DependentViewContext,
   ): boolean {
     const { value } = state;
-    let id: Uint64;
+    let id: bigint;
     if (typeof value === "number" || typeof value === "string") {
-      id = new Uint64();
-      if (!id.tryParseString(value.toString())) return false;
+      try {
+        id = parseUint64(value);
+      } catch {
+        return false;
+      }
     }
-    if (value instanceof Uint64) {
-      id = value.clone();
+    if (typeof value === "bigint") {
+      id = value;
     } else if (value instanceof Uint64MapEntry) {
-      id = value.key.clone();
+      id = value.key;
     } else {
       return false;
     }
@@ -1248,7 +1249,7 @@ export class SegmentationUserLayer extends Base {
     return displayed;
   }
 
-  moveToSegment(id: Uint64) {
+  moveToSegment(id: bigint) {
     for (const layer of this.renderLayers) {
       if (
         !(layer instanceof MultiscaleMeshLayer || layer instanceof MeshLayer)
diff --git a/src/mesh/backend.ts b/src/mesh/backend.ts
index fe8191a1b5..7f81d4434d 100644
--- a/src/mesh/backend.ts
+++ b/src/mesh/backend.ts
@@ -53,7 +53,6 @@ import {
   verifyObjectProperty,
   verifyStringArray,
 } from "#src/util/json.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { zorder3LessThan } from "#src/util/zorder.js";
 import {
   getBasePriority,
@@ -72,13 +71,13 @@ export type FragmentId = string;
 
 // Chunk that contains the list of fragments that make up a single object.
 export class ManifestChunk extends Chunk {
-  objectId = new Uint64();
+  objectId: bigint = 0n;
   fragmentIds: FragmentId[] | null;
   // We can't save a reference to objectId, because it may be a temporary
   // object.
-  initializeManifestChunk(key: string, objectId: Uint64) {
+  initializeManifestChunk(key: string, objectId: bigint) {
     super.initialize(key);
-    this.objectId.assign(objectId);
+    this.objectId = objectId;
   }
 
   freeSystemMemory() {
@@ -384,7 +383,7 @@ export class MeshSource extends ChunkSource {
     fragmentSource.meshSource = this;
   }
 
-  getChunk(objectId: Uint64) {
+  getChunk(objectId: bigint) {
     const key = getObjectKey(objectId);
     let chunk = <ManifestChunk>this.chunks.get(key);
     if (chunk === undefined) {
@@ -498,13 +497,13 @@ export class MeshLayer extends withSegmentationLayerBackendState(
 
 // Chunk that contains the list of fragments that make up a single object.
 export class MultiscaleManifestChunk extends Chunk {
-  objectId = new Uint64();
+  objectId: bigint = 0n;
   manifest: MultiscaleMeshManifest | undefined;
   // We can't save a reference to objectId, because it may be a temporary
   // object.
-  initializeManifestChunk(key: string, objectId: Uint64) {
+  initializeManifestChunk(key: string, objectId: bigint) {
     super.initialize(key);
-    this.objectId.assign(objectId);
+    this.objectId = objectId;
   }
 
   freeSystemMemory() {
@@ -584,7 +583,7 @@ export class MultiscaleMeshSource extends ChunkSource {
     fragmentSource.meshSource = this;
   }
 
-  getChunk(objectId: Uint64) {
+  getChunk(objectId: bigint) {
     const key = getObjectKey(objectId);
     let chunk = <MultiscaleManifestChunk>this.chunks.get(key);
     if (chunk === undefined) {
diff --git a/src/mesh/frontend.ts b/src/mesh/frontend.ts
index bccb3c9ec6..73c146a2ab 100644
--- a/src/mesh/frontend.ts
+++ b/src/mesh/frontend.ts
@@ -66,7 +66,6 @@ import {
   vec3,
 } from "#src/util/geom.js";
 import * as matrix from "#src/util/matrix.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import { GLBuffer } from "#src/webgl/buffer.js";
 import type { GL } from "#src/webgl/context.js";
 import { parameterizedEmitterDependentShaderGetter } from "#src/webgl/dynamic_shader.js";
@@ -587,7 +586,7 @@ export class MeshLayer extends PerspectiveViewRenderLayer<ThreeDimensionalRender
   }
 
   getObjectPosition(
-    id: Uint64,
+    id: bigint,
     nearestTo: Float32Array,
   ): Float32Array | undefined {
     const transform = this.displayState.transform.value;
@@ -1061,7 +1060,7 @@ export class MultiscaleMeshLayer extends PerspectiveViewRenderLayer<ThreeDimensi
     return hasAllChunks;
   }
 
-  getObjectPosition(id: Uint64): Float32Array | undefined {
+  getObjectPosition(id: bigint): Float32Array | undefined {
     const transform = this.displayState.transform.value;
     if (transform.error !== undefined) return undefined;
     const chunk = this.source.chunks.get(getObjectKey(id));
diff --git a/src/object_picking.ts b/src/object_picking.ts
index c2a3dfe38a..764fb647d0 100644
--- a/src/object_picking.ts
+++ b/src/object_picking.ts
@@ -16,7 +16,7 @@
 
 import type { MouseSelectionState } from "#src/layer/index.js";
 import type { RenderLayer } from "#src/renderlayer.js";
-import type { Uint64 } from "#src/util/uint64.js";
+import { uint64FromLowHigh } from "#src/util/bigint.js";
 
 const DEBUG_PICKING = false;
 
@@ -46,18 +46,17 @@ export class PickIDManager {
 
   registerUint64(
     renderLayer: RenderLayer,
-    x: Uint64,
+    x: bigint,
     count = 1,
     data: any = null,
   ): number {
-    return this.register(renderLayer, count, x.low, x.high, data);
+    return this.register(renderLayer, count, x, data);
   }
 
   register(
     renderLayer: RenderLayer,
     count = 1,
-    low = 0,
-    high = 0,
+    x: bigint = 0n,
     data: any = null,
   ): number {
     const { renderLayers, values } = this;
@@ -67,8 +66,8 @@ export class PickIDManager {
     renderLayers[index] = renderLayer;
     const valuesOffset = index * 3;
     values[valuesOffset] = pickID;
-    values[valuesOffset + 1] = low;
-    values[valuesOffset + 2] = high;
+    values[valuesOffset + 1] = Number(x & 0xffffffffn);
+    values[valuesOffset + 2] = Number(x >> 32n);
     this.pickData[index] = data;
     return pickID;
   }
@@ -101,9 +100,10 @@ export class PickIDManager {
         `offset=${pickedOffset}`,
       );
     }
-    const { pickedValue } = mouseState;
-    pickedValue.low = values[valuesOffset + 1];
-    pickedValue.high = values[valuesOffset + 2];
+    const pickedValue = (mouseState.pickedValue = uint64FromLowHigh(
+      values[valuesOffset + 1],
+      values[valuesOffset + 2],
+    ));
     mouseState.pickedAnnotationId = undefined;
     mouseState.pickedAnnotationLayer = undefined;
     mouseState.pickedAnnotationBuffer = undefined;
diff --git a/src/python_integration/api.ts b/src/python_integration/api.ts
index fa28d27e7c..359c74bd1c 100644
--- a/src/python_integration/api.ts
+++ b/src/python_integration/api.ts
@@ -18,6 +18,7 @@ import { debounce, throttle } from "lodash-es";
 import { StatusMessage } from "#src/status.js";
 import { RefCounted } from "#src/util/disposable.js";
 import { HttpError } from "#src/util/http_request.js";
+import { bigintToStringJsonReplacer } from "#src/util/json.js";
 import { getRandomHexString } from "#src/util/random.js";
 import type { Trackable } from "#src/util/trackable.js";
 import { getCachedJson } from "#src/util/trackable.js";
@@ -85,7 +86,10 @@ export class ClientStateSynchronizer extends RefCounted {
           return;
         }
         const newStateJson = getCachedJson(this.state).value;
-        const newStateEncoded = JSON.stringify(newStateJson);
+        const newStateEncoded = JSON.stringify(
+          newStateJson,
+          bigintToStringJsonReplacer,
+        );
         if (newStateEncoded === this.lastServerState) {
           // Avoid sending back the exact same state just received from or sent to the server.  This
           // is also important for making things work in the presence of multiple simultaneous
@@ -230,14 +234,14 @@ export class Client {
   sendActionNotification(action: string, state: any) {
     fetch(this.urls.action, {
       method: "POST",
-      body: JSON.stringify({ action, state }),
+      body: JSON.stringify({ action, state }, bigintToStringJsonReplacer),
     });
   }
 
   sendVolumeInfoNotification(requestId: string, info: any) {
     fetch(`${this.urls.volumeInfo}/${requestId}/info`, {
       method: "POST",
-      body: JSON.stringify(info),
+      body: JSON.stringify(info, bigintToStringJsonReplacer),
     });
   }
 
@@ -245,7 +249,7 @@ export class Client {
     const { data, ...params } = info;
     fetch(
       `${this.urls.volumeInfo}/${requestId}/chunk?p=${encodeURIComponent(
-        JSON.stringify(params),
+        JSON.stringify(params, bigintToStringJsonReplacer),
       )}`,
       { method: "POST", body: data },
     );
diff --git a/src/python_integration/remote_actions.ts b/src/python_integration/remote_actions.ts
index 274ae9b9d6..035fc88af0 100644
--- a/src/python_integration/remote_actions.ts
+++ b/src/python_integration/remote_actions.ts
@@ -22,7 +22,10 @@ import { debounce } from "lodash-es";
 import { TrackableValue } from "#src/trackable_value.js";
 import { RefCounted } from "#src/util/disposable.js";
 import { registerActionListener } from "#src/util/event_action_map.js";
-import { verifyStringArray } from "#src/util/json.js";
+import {
+  bigintToStringJsonReplacer,
+  verifyStringArray,
+} from "#src/util/json.js";
 import { Signal } from "#src/util/signal.js";
 import { getCachedJson } from "#src/util/trackable.js";
 import type { Viewer } from "#src/viewer.js";
@@ -78,7 +81,7 @@ export class RemoteActionHandler extends RefCounted {
     actionState.viewerState = getCachedJson(this.viewer.state).value;
     this.sendActionRequested.dispatch(
       action,
-      JSON.parse(JSON.stringify(actionState)),
+      JSON.parse(JSON.stringify(actionState, bigintToStringJsonReplacer)),
     );
   }
 }
diff --git a/src/python_integration/screenshots.ts b/src/python_integration/screenshots.ts
index ce8233d948..c2d7ebe016 100644
--- a/src/python_integration/screenshots.ts
+++ b/src/python_integration/screenshots.ts
@@ -25,7 +25,10 @@ import {
 import { toBase64 } from "#src/util/base64.js";
 import { RefCounted } from "#src/util/disposable.js";
 import { convertEndian32, Endianness } from "#src/util/endian.js";
-import { verifyOptionalString } from "#src/util/json.js";
+import {
+  bigintToStringJsonReplacer,
+  verifyOptionalString,
+} from "#src/util/json.js";
 import { Signal } from "#src/util/signal.js";
 import { getCachedJson } from "#src/util/trackable.js";
 import { ScreenshotMode } from "#src/util/trackable_screenshot_mode.js";
@@ -138,7 +141,10 @@ export class ScreenshotHandler extends RefCounted {
             JSON.stringify(getCachedJson(this.viewer.state).value),
           ),
           selectedValues: JSON.parse(
-            JSON.stringify(this.viewer.layerSelectedValues),
+            JSON.stringify(
+              this.viewer.layerSelectedValues,
+              bigintToStringJsonReplacer,
+            ),
           ),
           screenshotStatistics: { id: requestId, chunkSources: rows, total },
         };
@@ -207,7 +213,9 @@ export class ScreenshotHandler extends RefCounted {
       viewerState: JSON.parse(
         JSON.stringify(getCachedJson(this.viewer.state).value),
       ),
-      selectedValues: JSON.parse(JSON.stringify(layerSelectedValues)),
+      selectedValues: JSON.parse(
+        JSON.stringify(layerSelectedValues, bigintToStringJsonReplacer),
+      ),
       screenshot: {
         id: requestState,
         image,
diff --git a/src/renderlayer.ts b/src/renderlayer.ts
index 2fbea24894..583e2026ae 100644
--- a/src/renderlayer.ts
+++ b/src/renderlayer.ts
@@ -46,7 +46,6 @@ import { RefCounted } from "#src/util/disposable.js";
 import { mat4 } from "#src/util/geom.js";
 import { MessageList, MessageSeverity } from "#src/util/message_list.js";
 import { NullarySignal, Signal } from "#src/util/signal.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import { VisibilityPriorityAggregator } from "#src/visibility_priority/frontend.js";
 import type { RPC } from "#src/worker_rpc.js";
 import { registerSharedObjectOwner, SharedObject } from "#src/worker_rpc.js";
@@ -95,7 +94,7 @@ export class RenderLayer extends RefCounted {
    */
   updateMouseState(
     _mouseState: MouseSelectionState,
-    _pickedValue: Uint64,
+    _pickedValue: bigint,
     _pickedOffset: number,
     _data: any,
   ) {}
diff --git a/src/segment_color.browser_test.ts b/src/segment_color.browser_test.ts
index e8e34eff81..63accea892 100644
--- a/src/segment_color.browser_test.ts
+++ b/src/segment_color.browser_test.ts
@@ -19,8 +19,8 @@ import {
   SegmentColorHash,
   SegmentColorShaderManager,
 } from "#src/segment_color.js";
+import { randomUint64 } from "#src/util/bigint.js";
 import { DataType } from "#src/util/data_type.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { fragmentShaderTest } from "#src/webgl/shader_testing.js";
 
 describe("segment_color", () => {
@@ -44,7 +44,7 @@ outB = color.b;
         shader.bind();
         shaderManager.enable(gl, shader, colorHash.value);
 
-        function testValue(x: Uint64) {
+        function testValue(x: bigint) {
           tester.execute({ inputValue: x });
           const expected = new Float32Array(3);
           colorHash.compute(expected, x);
@@ -54,11 +54,11 @@ outB = color.b;
           expect(values.outB).toBeCloseTo(expected[2]);
         }
 
-        testValue(Uint64.parseString("0"));
-        testValue(Uint64.parseString("8"));
+        testValue(0n);
+        testValue(8n);
         const COUNT = 100;
         for (let iter = 0; iter < COUNT; ++iter) {
-          const x = Uint64.random();
+          const x = randomUint64();
           testValue(x);
         }
       },
diff --git a/src/segment_color.ts b/src/segment_color.ts
index db966a9f4a..9cc2ff2f19 100644
--- a/src/segment_color.ts
+++ b/src/segment_color.ts
@@ -25,7 +25,6 @@ import { hsvToRgb } from "#src/util/colorspace.js";
 import { getRandomUint32 } from "#src/util/random.js";
 import { NullarySignal } from "#src/util/signal.js";
 import type { Trackable } from "#src/util/trackable.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import type { GL } from "#src/webgl/context.js";
 import type { ShaderBuilder, ShaderProgram } from "#src/webgl/shader.js";
 import { glsl_hsvToRgb, glsl_uint64 } from "#src/webgl/shader_lib.js";
@@ -95,16 +94,16 @@ export class SegmentColorHash implements Trackable {
     }
   }
 
-  compute(out: Float32Array, x: Uint64) {
-    let h = hashCombine(this.hashSeed, x.low);
-    h = hashCombine(h, x.high);
+  compute(out: Float32Array, x: bigint) {
+    let h = hashCombine(this.hashSeed, Number(x & 0xffffffffn));
+    h = hashCombine(h, Number(x >> 32n));
     const c0 = (h & 0xff) / 255;
     const c1 = ((h >> 8) & 0xff) / 255;
     hsvToRgb(out, c0, 0.5 + 0.5 * c1, 1.0);
     return out;
   }
 
-  computeCssColor(x: Uint64) {
+  computeCssColor(x: bigint) {
     this.compute(tempColor, x);
     return getCssColor(tempColor);
   }
diff --git a/src/segmentation_display_state/base.ts b/src/segmentation_display_state/base.ts
index 6b09716531..ea37ea4f52 100644
--- a/src/segmentation_display_state/base.ts
+++ b/src/segmentation_display_state/base.ts
@@ -20,7 +20,6 @@ import type { SharedWatchableValue } from "#src/shared_watchable_value.js";
 import type { Uint64OrderedSet } from "#src/uint64_ordered_set.js";
 import type { Uint64Set } from "#src/uint64_set.js";
 import type { RefCounted } from "#src/util/disposable.js";
-import type { Uint64 } from "#src/util/uint64.js";
 
 export interface VisibleSegmentsState {
   visibleSegments: Uint64Set;
@@ -73,15 +72,14 @@ export function onTemporaryVisibleSegmentsStateChanged(
 }
 
 /**
- * Returns a string key for identifying a uint64 object id.  This is faster than
- * Uint64.prototype.toString().
+ * Returns a string key for identifying a uint64 object id.
  */
-export function getObjectKey(objectId: Uint64): string {
-  return `${objectId.low},${objectId.high}`;
+export function getObjectKey(objectId: bigint): string {
+  return objectId.toString();
 }
 
-function isHighBitSegment(segmentId: Uint64): boolean {
-  return segmentId.high >>> 31 ? true : false;
+function isHighBitSegment(segmentId: bigint): boolean {
+  return (segmentId & 0x8000000000000000n) !== 0n;
 }
 
 export function getVisibleSegments(state: VisibleSegmentsState) {
@@ -98,13 +96,13 @@ export function getSegmentEquivalences(state: VisibleSegmentsState) {
 
 export function forEachVisibleSegment(
   state: VisibleSegmentsState,
-  callback: (objectId: Uint64, rootObjectId: Uint64) => void,
+  callback: (objectId: bigint, rootObjectId: bigint) => void,
 ) {
   const visibleSegments = getVisibleSegments(state);
   const segmentEquivalences = getSegmentEquivalences(state);
   const equivalencePolicy =
     segmentEquivalences.disjointSets.visibleSegmentEquivalencePolicy.value;
-  for (const rootObjectId of visibleSegments.unsafeKeys()) {
+  for (const rootObjectId of visibleSegments.keys()) {
     if (
       equivalencePolicy &
       VisibleSegmentEquivalencePolicy.NONREPRESENTATIVE_EXCLUDED
diff --git a/src/segmentation_display_state/frontend.ts b/src/segmentation_display_state/frontend.ts
index df36d12496..f9397cae52 100644
--- a/src/segmentation_display_state/frontend.ts
+++ b/src/segmentation_display_state/frontend.ts
@@ -46,14 +46,15 @@ import type {
 import { observeWatchable, registerNestedSync } from "#src/trackable_value.js";
 import { isWithinSelectionPanel } from "#src/ui/selection_details.js";
 import type { Uint64Map } from "#src/uint64_map.js";
+import { wrapSigned32BitIntegerToUint64 } from "#src/util/bigint.js";
 import { setClipboard } from "#src/util/clipboard.js";
 import { useWhiteBackground } from "#src/util/color.js";
 import { RefCounted } from "#src/util/disposable.js";
 import { measureElementClone } from "#src/util/dom.js";
 import type { vec3 } from "#src/util/geom.js";
 import { kOneVec, vec4 } from "#src/util/geom.js";
+import { parseUint64 } from "#src/util/json.js";
 import { NullarySignal } from "#src/util/signal.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { withSharedVisibility } from "#src/visibility_priority/frontend.js";
 import { makeCopyButton } from "#src/widget/copy_button.js";
 import { makeEyeButton } from "#src/widget/eye_button.js";
@@ -62,8 +63,8 @@ import { makeStarButton } from "#src/widget/star_button.js";
 
 export class Uint64MapEntry {
   constructor(
-    public key: Uint64,
-    public value?: Uint64,
+    public key: bigint,
+    public value?: bigint,
     public label?: string | undefined,
   ) {}
   toString() {
@@ -80,8 +81,8 @@ export class Uint64MapEntry {
 }
 
 export class SegmentSelectionState extends RefCounted {
-  selectedSegment = new Uint64();
-  baseSelectedSegment = new Uint64();
+  selectedSegment = 0n;
+  baseSelectedSegment = 0n;
   hasSelectedSegment = false;
   changed = new NullarySignal();
 
@@ -94,36 +95,30 @@ export class SegmentSelectionState extends RefCounted {
   }
 
   set(
-    value: number | Uint64MapEntry | Uint64 | null | undefined,
+    value: number | Uint64MapEntry | bigint | null | undefined,
     hideSegmentZero = false,
   ) {
     const { selectedSegment, baseSelectedSegment } = this;
-    let newLow = 0;
-    let newHigh = 0;
-    let newBaseLow = 0;
-    let newBaseHigh = 0;
+    let newId = 0n;
+    let newBaseId = 0n;
     let hasSelectedSegment: boolean;
     if (value == null) {
       hasSelectedSegment = false;
     } else if (typeof value === "number") {
-      newLow = newBaseLow = value >>> 0;
-      newHigh = newBaseHigh = value < 0 ? 0xffffffff : 0;
+      newId = newBaseId = wrapSigned32BitIntegerToUint64(value);
       hasSelectedSegment = true;
     } else if (value instanceof Uint64MapEntry) {
       const valueMapped = value.value || value.key;
-      newLow = valueMapped.low;
-      newHigh = valueMapped.high;
-      newBaseLow = value.key.low;
-      newBaseHigh = value.key.high;
+      newId = valueMapped;
+      newBaseId = value.key;
       hasSelectedSegment = true;
-    } else if (value instanceof Uint64) {
-      newLow = newBaseLow = value.low;
-      newHigh = newBaseHigh = value.high;
+    } else if (typeof value === "bigint") {
+      newId = newBaseId = value;
       hasSelectedSegment = true;
     } else {
       hasSelectedSegment = false;
     }
-    if (hideSegmentZero && newLow === 0 && newHigh === 0) {
+    if (hideSegmentZero && newId === 0n) {
       hasSelectedSegment = false;
     }
     if (!hasSelectedSegment) {
@@ -134,22 +129,18 @@ export class SegmentSelectionState extends RefCounted {
     } else if (
       hasSelectedSegment &&
       (!this.hasSelectedSegment ||
-        selectedSegment.low !== newLow ||
-        selectedSegment.high !== newHigh ||
-        baseSelectedSegment.low !== newBaseLow ||
-        baseSelectedSegment.high !== newBaseHigh)
+        selectedSegment !== newId ||
+        baseSelectedSegment !== newBaseId)
     ) {
-      selectedSegment.low = newLow;
-      selectedSegment.high = newHigh;
-      baseSelectedSegment.low = newBaseLow;
-      baseSelectedSegment.high = newBaseHigh;
+      this.selectedSegment = newId;
+      this.baseSelectedSegment = newBaseId;
       this.hasSelectedSegment = true;
       this.changed.dispatch();
     }
   }
 
-  isSelected(value: Uint64) {
-    return this.hasSelectedSegment && Uint64.equal(value, this.selectedSegment);
+  isSelected(value: bigint) {
+    return this.hasSelectedSegment && value === this.selectedSegment;
   }
 
   bindTo(
@@ -200,9 +191,9 @@ export interface SegmentationDisplayState {
   segmentationGroupState: WatchableValueInterface<SegmentationGroupState>;
   segmentationColorGroupState: WatchableValueInterface<SegmentationColorGroupState>;
 
-  selectSegment: (id: Uint64, pin: boolean | "toggle") => void;
-  filterBySegmentLabel: (id: Uint64) => void;
-  moveToSegment: (id: Uint64) => void;
+  selectSegment: (id: bigint, pin: boolean | "toggle") => void;
+  filterBySegmentLabel: (id: bigint) => void;
+  moveToSegment: (id: bigint) => void;
 
   // Indirect properties
   hideSegmentZero: WatchableValueInterface<boolean>;
@@ -224,22 +215,21 @@ export function resetTemporaryVisibleSegmentsState(
   state.temporarySegmentEquivalences.clear();
 }
 
-/// Converts a segment id to a Uint64MapEntry or Uint64 (if Uint64MapEntry would add no additional
+/// Converts a segment id to a Uint64MapEntry or uint64 (if Uint64MapEntry would add no additional
 /// information).
 export function maybeAugmentSegmentId(
   displayState: SegmentationDisplayState | undefined | null,
-  value: number | Uint64,
-  mustCopy = false,
-): Uint64 | Uint64MapEntry {
-  let id: Uint64;
-  let mappedValue: Uint64;
-  let mapped: Uint64 | undefined;
+  value: number | bigint | string,
+): bigint | Uint64MapEntry {
+  let id: bigint;
+  let mappedValue: bigint;
+  let mapped: bigint | undefined;
   if (typeof value === "number") {
-    id = new Uint64(value >>> 0, value < 0 ? 0xffffffff : 0);
+    id = wrapSigned32BitIntegerToUint64(value);
   } else if (typeof value === "string") {
-    id = Uint64.parseString(value);
+    id = parseUint64(value);
   } else {
-    id = mustCopy ? value.clone() : value;
+    id = value;
   }
   if (displayState == null) return id;
   const {
@@ -248,7 +238,7 @@ export function maybeAugmentSegmentId(
   } = displayState.segmentationGroupState.value;
   if (segmentEquivalences.size !== 0) {
     mappedValue = segmentEquivalences.get(id);
-    if (Uint64.equal(mappedValue, id)) {
+    if (mappedValue === id) {
       mapped = undefined;
     } else {
       mapped = mappedValue;
@@ -266,11 +256,11 @@ export function maybeAugmentSegmentId(
 /// Converts a plain segment id to a Uint64MapEntry.
 export function augmentSegmentId(
   displayState: SegmentationDisplayState | undefined | null,
-  value: number | Uint64 | Uint64MapEntry,
+  value: number | bigint | Uint64MapEntry,
 ): Uint64MapEntry {
   if (value instanceof Uint64MapEntry) return value;
   const newValue = maybeAugmentSegmentId(displayState, value);
-  if (newValue instanceof Uint64) {
+  if (typeof newValue === "bigint") {
     return new Uint64MapEntry(newValue);
   }
   return newValue;
@@ -426,8 +416,7 @@ function makeRegisterSegmentWidgetEventHandlers(
   const onMouseEnter = (event: Event) => {
     const entryElement = event.currentTarget as HTMLElement;
     const idString = entryElement.dataset.id!;
-    const id = tempStatedColor;
-    id.tryParseString(idString);
+    const id = BigInt(idString);
     displayState.segmentSelectionState.set(id);
     if (!isWithinSelectionPanel(entryElement)) {
       displayState.selectSegment(id, false);
@@ -437,8 +426,7 @@ function makeRegisterSegmentWidgetEventHandlers(
   const selectHandler = (event: Event) => {
     const entryElement = event.currentTarget as HTMLElement;
     const idString = entryElement.dataset.id!;
-    const id = tempStatedColor;
-    id.tryParseString(idString);
+    const id = BigInt(idString);
     displayState.selectSegment(
       id,
       isWithinSelectionPanel(entryElement) ? "toggle" : true,
@@ -470,8 +458,7 @@ function makeRegisterSegmentWidgetEventHandlers(
   const visibleCheckboxHandler = (event: Event) => {
     const entryElement = getEntryElement(event);
     const idString = entryElement.dataset.id!;
-    const id = tempStatedColor;
-    id.tryParseString(idString);
+    const id = BigInt(idString);
     const { selectedSegments, visibleSegments } =
       displayState.segmentationGroupState.value;
     const shouldBeVisible = !visibleSegments.has(id);
@@ -486,8 +473,7 @@ function makeRegisterSegmentWidgetEventHandlers(
   const filterHandler = (event: Event) => {
     const entryElement = getEntryElement(event);
     const idString = entryElement.dataset.id!;
-    const id = tempStatedColor;
-    id.tryParseString(idString);
+    const id = BigInt(idString);
     displayState.filterBySegmentLabel(id);
     event.stopPropagation();
   };
@@ -504,8 +490,7 @@ function makeRegisterSegmentWidgetEventHandlers(
     }
     const entryElement = event.currentTarget as HTMLElement;
     const idString = entryElement.dataset.id!;
-    const id = tempStatedColor;
-    id.tryParseString(idString);
+    const id = BigInt(idString);
     displayState.moveToSegment(id);
   };
 
@@ -539,8 +524,7 @@ function makeRegisterSegmentWidgetEventHandlers(
     starButton.addEventListener("click", (event: MouseEvent) => {
       const entryElement = getEntryElement(event);
       const idString = entryElement.dataset.id!;
-      const id = tempStatedColor;
-      id.tryParseString(idString);
+      const id = BigInt(idString);
       const { selectedSegments } = displayState.segmentationGroupState.value;
       selectedSegments.set(id, !selectedSegments.has(id));
     });
@@ -577,7 +561,7 @@ export class SegmentWidgetFactory<Template extends SegmentWidgetTemplate> {
     );
   }
 
-  get(rawId: Uint64 | number): HTMLDivElement {
+  get(rawId: bigint | number): HTMLDivElement {
     const { displayState } = this;
     return this.getWithNormalizedId(augmentSegmentId(displayState, rawId));
   }
@@ -609,7 +593,7 @@ export class SegmentWidgetFactory<Template extends SegmentWidgetTemplate> {
       const unmappedIdElement = idContainer.children[
         unmappedIdIndex
       ] as HTMLElement;
-      if (!Uint64.equal(id, mapped)) {
+      if (id !== mapped) {
         const unmappedIdString = id.toString();
         container.dataset.unmappedId = unmappedIdString;
         unmappedIdElement.textContent = unmappedIdString;
@@ -641,14 +625,13 @@ export class SegmentWidgetFactory<Template extends SegmentWidgetTemplate> {
   }
 
   update(container: HTMLElement) {
-    const id = tempStatedColor;
     const idString = container.dataset.id;
     if (idString === undefined) return;
-    id.parseString(idString);
+    const id = BigInt(idString);
     this.updateWithId(container, id);
   }
 
-  private updateWithId(container: HTMLElement, mapped: Uint64) {
+  private updateWithId(container: HTMLElement, mapped: bigint) {
     const { children } = container;
     const stickyChildren = children[0].children;
     const { template } = this;
@@ -660,7 +643,7 @@ export class SegmentWidgetFactory<Template extends SegmentWidgetTemplate> {
     ).classList.toggle("neuroglancer-visible", visibleSegments.has(mapped));
     container.dataset.selected = (
       segmentSelectionState.hasSelectedSegment &&
-      Uint64.equal(segmentSelectionState.selectedSegment, mapped)
+      segmentSelectionState.selectedSegment === mapped
     ).toString();
     const { selectedSegments } = displayState!.segmentationGroupState.value;
     (stickyChildren[template.starIndex] as HTMLInputElement).classList.toggle(
@@ -682,8 +665,7 @@ export class SegmentWidgetFactory<Template extends SegmentWidgetTemplate> {
         displayState!.baseSegmentColoring.value &&
         (unmappedIdString = container.dataset.unmappedId) !== undefined
       ) {
-        const unmappedId = tempStatedColor;
-        unmappedId.parseString(unmappedIdString);
+        const unmappedId = BigInt(unmappedIdString);
         color = getBaseObjectColor(this.displayState, unmappedId) as vec3;
       } else {
         color = kOneVec;
@@ -941,11 +923,10 @@ export function registerRedrawWhenSegmentationDisplayState3DChanged(
  * Temporary values used by getObjectColor.
  */
 const tempColor = vec4.create();
-const tempStatedColor = new Uint64();
 
 export function getBaseObjectColor(
   displayState: SegmentationDisplayState | undefined | null,
-  objectId: Uint64,
+  objectId: bigint,
   color: Float32Array = tempColor,
 ) {
   if (displayState == null) {
@@ -954,14 +935,16 @@ export function getBaseObjectColor(
   }
   const colorGroupState = displayState.segmentationColorGroupState.value;
   const { segmentStatedColors } = colorGroupState;
+  let statedColor: bigint | undefined;
   if (
     segmentStatedColors.size !== 0 &&
-    colorGroupState.segmentStatedColors.get(objectId, tempStatedColor)
+    (statedColor = colorGroupState.segmentStatedColors.get(objectId)) !==
+      undefined
   ) {
     // If displayState maps the ID to a color, use it
-    color[0] = (tempStatedColor.low & 0x0000ff) / 255.0;
-    color[1] = ((tempStatedColor.low & 0x00ff00) >>> 8) / 255.0;
-    color[2] = ((tempStatedColor.low & 0xff0000) >>> 16) / 255.0;
+    color[0] = Number(statedColor & 0x0000ffn) / 255.0;
+    color[1] = (Number(statedColor & 0x00ff00n) >>> 8) / 255.0;
+    color[2] = (Number(statedColor & 0xff0000n) >>> 16) / 255.0;
     return color;
   }
   const segmentDefaultColor = colorGroupState.segmentDefaultColor.value;
@@ -980,7 +963,7 @@ export function getBaseObjectColor(
  */
 export function getObjectColor(
   displayState: SegmentationDisplayState,
-  objectId: Uint64,
+  objectId: bigint,
   alpha = 1,
 ) {
   const color = tempColor;
@@ -1061,10 +1044,10 @@ export function forEachVisibleSegmentToDraw(
   emitColor: boolean,
   pickIDs: PickIDManager | undefined,
   callback: (
-    objectId: Uint64,
+    objectId: bigint,
     color: vec4 | undefined,
     pickIndex: number | undefined,
-    rootObjectId: Uint64,
+    rootObjectId: bigint,
   ) => void,
 ) {
   const alpha = Math.min(1, displayState.objectAlpha.value);
diff --git a/src/segmentation_display_state/property_map.spec.ts b/src/segmentation_display_state/property_map.spec.ts
index 51305ac3da..f5d20923d0 100644
--- a/src/segmentation_display_state/property_map.spec.ts
+++ b/src/segmentation_display_state/property_map.spec.ts
@@ -22,21 +22,20 @@ import {
   SegmentPropertyMap,
 } from "#src/segmentation_display_state/property_map.js";
 import { DataType } from "#src/util/data_type.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 describe("PreprocessedSegmentPropertyMap", () => {
   test("handles lookups correctly", () => {
     const map = new PreprocessedSegmentPropertyMap({
       inlineProperties: {
-        ids: Uint32Array.of(5, 0, 15, 0, 20, 5),
+        ids: BigUint64Array.of(5n, 15n, 0x500000014n),
         properties: [],
       },
     });
-    expect(map.getSegmentInlineIndex(new Uint64(5, 0))).toEqual(0);
-    expect(map.getSegmentInlineIndex(new Uint64(15, 0))).toEqual(1);
-    expect(map.getSegmentInlineIndex(new Uint64(20, 5))).toEqual(2);
-    expect(map.getSegmentInlineIndex(new Uint64(30, 5))).toEqual(-1);
-    expect(map.getSegmentInlineIndex(new Uint64(0, 0))).toEqual(-1);
+    expect(map.getSegmentInlineIndex(5n)).toEqual(0);
+    expect(map.getSegmentInlineIndex(15n)).toEqual(1);
+    expect(map.getSegmentInlineIndex(0x500000014n)).toEqual(2);
+    expect(map.getSegmentInlineIndex(0x50000001en)).toEqual(-1);
+    expect(map.getSegmentInlineIndex(0n)).toEqual(-1);
   });
 });
 
@@ -44,13 +43,13 @@ describe("mergeSegmentPropertyMaps", () => {
   test("works correctly for 2 maps", () => {
     const a = new SegmentPropertyMap({
       inlineProperties: {
-        ids: Uint32Array.of(5, 0, 6, 0, 8, 0),
+        ids: BigUint64Array.of(5n, 6n, 8n),
         properties: [{ type: "string", id: "prop1", values: ["x", "y", "z"] }],
       },
     });
     const b = new SegmentPropertyMap({
       inlineProperties: {
-        ids: Uint32Array.of(5, 0, 7, 0),
+        ids: BigUint64Array.of(5n, 7n),
         properties: [{ type: "string", id: "prop2", values: ["a", "b"] }],
       },
     });
@@ -59,7 +58,7 @@ describe("mergeSegmentPropertyMaps", () => {
     expect(mergeSegmentPropertyMaps([b])).toBe(b);
     const c = mergeSegmentPropertyMaps([a, b]);
     expect(c?.inlineProperties).toEqual({
-      ids: Uint32Array.of(5, 0, 6, 0, 7, 0, 8, 0),
+      ids: BigUint64Array.of(5n, 6n, 7n, 8n),
       properties: [
         { type: "string", id: "prop1", values: ["x", "y", "", "z"] },
         { type: "string", id: "prop2", values: ["a", "", "b", ""] },
@@ -71,7 +70,7 @@ describe("mergeSegmentPropertyMaps", () => {
 describe("parseSegmentQuery", () => {
   const map = new PreprocessedSegmentPropertyMap({
     inlineProperties: {
-      ids: Uint32Array.of(),
+      ids: BigUint64Array.of(),
       properties: [
         { type: "label", id: "label", values: [] },
         {
@@ -116,7 +115,7 @@ describe("parseSegmentQuery", () => {
     expect(parseSegmentQuery(undefined, "123")).toMatchInlineSnapshot(`
       {
         "ids": [
-          "123",
+          123n,
         ],
       }
     `);
@@ -126,8 +125,8 @@ describe("parseSegmentQuery", () => {
     expect(parseSegmentQuery(undefined, "123 456")).toMatchInlineSnapshot(`
       {
         "ids": [
-          "123",
-          "456",
+          123n,
+          456n,
         ],
       }
     `);
diff --git a/src/segmentation_display_state/property_map.ts b/src/segmentation_display_state/property_map.ts
index 4c5d4313f3..f84961cf55 100644
--- a/src/segmentation_display_state/property_map.ts
+++ b/src/segmentation_display_state/property_map.ts
@@ -19,11 +19,17 @@ import { ChunkSource } from "#src/chunk_manager/frontend.js";
 import type { IndexedSegmentProperty } from "#src/segmentation_display_state/base.js";
 import type { Uint64OrderedSet } from "#src/uint64_ordered_set.js";
 import type { Uint64Set } from "#src/uint64_set.js";
-import type { TypedNumberArray, WritableArrayLike } from "#src/util/array.js";
+import type {
+  TypedArray,
+  TypedNumberArray,
+  WritableArrayLike,
+} from "#src/util/array.js";
 import { mergeSequences } from "#src/util/array.js";
+import { bigintCompare } from "#src/util/bigint.js";
 import { DataType } from "#src/util/data_type.js";
 import type { Borrowed } from "#src/util/disposable.js";
-import { murmurHash3_x86_32Hash64Bits } from "#src/util/hash.js";
+import { murmurHash3_x86_32Hash64Bits_Bigint } from "#src/util/hash.js";
+import { parseUint64 } from "#src/util/json.js";
 import type { DataTypeInterval } from "#src/util/lerp.js";
 import {
   clampToInterval,
@@ -34,7 +40,6 @@ import {
 } from "#src/util/lerp.js";
 import { getObjectId } from "#src/util/object_id.js";
 import { defaultStringCompare } from "#src/util/string.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 export type InlineSegmentProperty =
   | InlineSegmentStringProperty
@@ -69,8 +74,7 @@ export interface InlineSegmentNumericalProperty {
 }
 
 export interface InlineSegmentPropertyMap {
-  // Specifies low/high 32-bit portions of ids.
-  ids: Uint32Array<ArrayBuffer>;
+  ids: BigUint64Array<ArrayBuffer>;
   properties: InlineSegmentProperty[];
 }
 
@@ -125,18 +129,16 @@ function makeIndicesArray(size: number, maxValue: number): IndicesArray {
   return new Uint32Array(size);
 }
 
-function makeUint64PermutationHashMap(values: Uint32Array): IndicesArray {
+function makeUint64PermutationHashMap(values: BigUint64Array): IndicesArray {
   // Use twice the next power of 2 as the size.  This ensures a load factor <= 0.5.
-  const numEntries = values.length / 2;
+  const numEntries = values.length;
   const hashCodeBits = Math.ceil(Math.log2(numEntries)) + 1;
   const size = 2 ** hashCodeBits;
   const table = makeIndicesArray(size, numEntries + 1);
   for (let i = 0; i < numEntries; ++i) {
-    const low = values[2 * i];
-    const high = values[2 * i + 1];
     insertIntoLinearChainingTable(
       table,
-      murmurHash3_x86_32Hash64Bits(/*seed=*/ 0, low, high),
+      murmurHash3_x86_32Hash64Bits_Bigint(/*seed=*/ 0, values[i]),
       i + 1,
     );
   }
@@ -145,18 +147,17 @@ function makeUint64PermutationHashMap(values: Uint32Array): IndicesArray {
 
 function queryUint64PermutationHashMap(
   table: TypedNumberArray,
-  values: Uint32Array,
-  low: number,
-  high: number,
+  values: BigUint64Array,
+  x: bigint,
 ): number {
-  let hashCode = murmurHash3_x86_32Hash64Bits(/*seed=*/ 0, low, high);
+  let hashCode = murmurHash3_x86_32Hash64Bits_Bigint(/*seed=*/ 0, x);
   const mask = table.length - 1;
   while (true) {
     hashCode = hashCode & mask;
     let index = table[hashCode];
     if (index === 0) return -1;
     --index;
-    if (values[2 * index] === low && values[2 * index + 1] === high) {
+    if (values[index] === x) {
       return index;
     }
     ++hashCode;
@@ -180,14 +181,13 @@ export class PreprocessedSegmentPropertyMap {
   labels: InlineSegmentStringProperty | undefined;
   numericalProperties: InlineSegmentNumericalProperty[];
 
-  getSegmentInlineIndex(id: Uint64): number {
+  getSegmentInlineIndex(id: bigint): number {
     const { inlineIdToIndex } = this;
     if (inlineIdToIndex === undefined) return -1;
     return queryUint64PermutationHashMap(
       inlineIdToIndex,
       this.segmentPropertyMap.inlineProperties!.ids,
-      id.low,
-      id.high,
+      id,
     );
   }
 
@@ -207,7 +207,7 @@ export class PreprocessedSegmentPropertyMap {
     ) ?? []) as InlineSegmentNumericalProperty[];
   }
 
-  getSegmentLabel(id: Uint64): string | undefined {
+  getSegmentLabel(id: bigint): string | undefined {
     const index = this.getSegmentInlineIndex(id);
     if (index === -1) return undefined;
     const { labels, tags: tagsProperty } = this;
@@ -242,17 +242,9 @@ function remapArray<T>(
   }
 }
 
-function isIdArraySorted(ids: Uint32Array): boolean {
-  const n = ids.length;
-  if (n === 0) return true;
-  let prevLow = ids[0];
-  let prevHigh = ids[1];
-  for (let i = 0; i < n; i += 2) {
-    const low = ids[i];
-    const high = ids[i + 1];
-    if ((high - prevHigh || low - prevLow) <= 0) return false;
-    prevLow = low;
-    prevHigh = high;
+function isIdArraySorted(ids: TypedArray): boolean {
+  for (let i = 1, n = ids.length; i < n; ++i) {
+    if (ids[i] <= ids[0]) return false;
   }
   return true;
 }
@@ -265,23 +257,16 @@ export function normalizeInlineSegmentPropertyMap(
   if (isIdArraySorted(ids)) {
     return inlineProperties;
   }
-  const length = ids.length / 2;
+  const length = ids.length;
   const permutation = makeIndicesArray(length, length - 1);
   for (let i = 0; i < length; ++i) {
     permutation[i] = i;
   }
-  permutation.sort((a, b) => {
-    const aLow = ids[a * 2];
-    const aHigh = ids[a * 2 + 1];
-    const bLow = ids[b * 2];
-    const bHigh = ids[b * 2 + 1];
-    return aHigh - bHigh || aLow - bLow;
-  });
-  const newIds = new Uint32Array(length * 2);
+  permutation.sort((a, b) => bigintCompare(ids[a], ids[b]));
+  const newIds = new BigUint64Array(length);
   for (let newIndex = 0; newIndex < length; ++newIndex) {
     const oldIndex = permutation[newIndex];
-    newIds[newIndex * 2] = ids[oldIndex * 2];
-    newIds[newIndex * 2 + 1] = ids[oldIndex * 2 + 1];
+    newIds[newIndex] = ids[oldIndex];
   }
   const properties = inlineProperties.properties.map((property) => {
     const { values } = property;
@@ -349,8 +334,8 @@ function mergeInlinePropertyMaps(
   if (b === undefined) return a;
   // Determine number of unique ids and mapping from `a` and `b` indices to joined indices.
   let numUnique = 0;
-  const aCount = a.ids.length / 2;
-  const bCount = b.ids.length / 2;
+  const aCount = a.ids.length;
+  const bCount = b.ids.length;
   const aToMerged = new Uint32Array(aCount);
   const bToMerged = new Uint32Array(bCount);
   const aIds = a.ids;
@@ -358,13 +343,7 @@ function mergeInlinePropertyMaps(
   mergeSequences(
     aCount,
     bCount,
-    (a, b) => {
-      const aHigh = aIds[2 * a + 1];
-      const aLow = aIds[2 * a];
-      const bHigh = bIds[2 * b + 1];
-      const bLow = bIds[2 * b];
-      return aHigh - bHigh || aLow - bLow;
-    },
+    (a, b) => bigintCompare(aIds[a], bIds[b]),
     (a) => {
       aToMerged[a] = numUnique;
       ++numUnique;
@@ -379,22 +358,20 @@ function mergeInlinePropertyMaps(
       ++numUnique;
     },
   );
-  let ids: Uint32Array<ArrayBuffer>;
+  let ids: BigUint64Array<ArrayBuffer>;
   if (numUnique === aCount) {
     ids = aIds;
   } else if (numUnique === bCount) {
     ids = bIds;
   } else {
-    ids = new Uint32Array(numUnique * 2);
+    ids = new BigUint64Array(numUnique);
     for (let a = 0; a < aCount; ++a) {
       const i = aToMerged[a];
-      ids[2 * i] = aIds[2 * a];
-      ids[2 * i + 1] = aIds[2 * a + 1];
+      ids[i] = aIds[a];
     }
     for (let b = 0; b < bCount; ++b) {
       const i = bToMerged[b];
-      ids[2 * i] = bIds[2 * b];
-      ids[2 * i + 1] = bIds[2 * b + 1];
+      ids[i] = bIds[b];
     }
   }
   const properties: InlineSegmentProperty[] = [];
@@ -465,7 +442,7 @@ export interface SortBy {
 }
 
 export interface ExplicitIdQuery {
-  ids: Uint64[];
+  ids: bigint[];
   prefix?: undefined;
   regexp?: undefined;
   includeTags?: undefined;
@@ -521,21 +498,19 @@ export function parseSegmentQuery(
 ): QueryParseResult {
   if (queryString.match(idPattern) !== null) {
     const parts = queryString.split(/[\s,]+/);
-    const ids: Uint64[] = [];
-    const idSet = new Set<string>();
+    const idSet = new Set<bigint>();
     for (let i = 0, n = parts.length; i < n; ++i) {
       const part = parts[i];
       if (part === "") continue;
-      const id = new Uint64();
-      if (!id.tryParseString(part)) {
+      let id: bigint;
+      try {
+        id = parseUint64(part);
+      } catch {
         continue;
       }
-      const idString = id.toString();
-      if (idSet.has(idString)) continue;
-      idSet.add(idString);
-      ids.push(id);
+      idSet.add(id);
     }
-    ids.sort(Uint64.compare);
+    const ids = Array.from(idSet).sort(bigintCompare);
     return { ids };
   }
   const parsed: FilterQuery = {
@@ -823,7 +798,7 @@ export interface QueryResult {
   intermediateIndicesMask?: Uint32Array | Uint16Array | Uint8Array | undefined;
   // Indices into the inline properties table that satisfy all constraints.  Sorting is applied.
   indices?: IndicesArray | undefined;
-  explicitIds?: Uint64[] | undefined;
+  explicitIds?: bigint[] | undefined;
   tags?: TagCount[] | undefined;
   count: number;
   total: number;
@@ -854,7 +829,7 @@ export function executeSegmentQuery(
     };
   }
   const properties = inlineProperties?.properties;
-  const totalIds = inlineProperties.ids.length / 2;
+  const totalIds = inlineProperties.ids.length;
   const totalTags = db?.tags?.tags?.length || 0;
   let indices = makeIndicesArray(totalIds, totalIds);
   const showTags = makeIndicesArray(totalTags, totalTags);
@@ -1169,11 +1144,7 @@ export function updatePropertyHistograms(
     if (
       propertyHistogram !== undefined &&
       propertyHistogram.queryResult === queryResult &&
-      dataTypeIntervalEqual(
-        property.dataType,
-        propertyHistogram.window,
-        propertyBounds,
-      )
+      dataTypeIntervalEqual(propertyHistogram.window, propertyBounds)
     ) {
       continue;
     }
@@ -1217,7 +1188,7 @@ export function unparseSegmentQuery(
     const { fieldId, bounds } = constraint;
     const [min, max] = bounds as [number, number];
     const property = db!.numericalProperties.find((p) => p.id === fieldId)!;
-    if (dataTypeIntervalEqual(property.dataType, property.bounds, bounds)) {
+    if (dataTypeIntervalEqual(property.bounds, bounds)) {
       continue;
     }
     if (dataTypeCompare(min, max) === 0) {
@@ -1272,11 +1243,10 @@ export function unparseSegmentQuery(
   return queryString;
 }
 
-const tempUint64 = new Uint64();
 export function forEachQueryResultSegmentId(
   db: PreprocessedSegmentPropertyMap | undefined,
   queryResult: QueryResult | undefined,
-  callback: (id: Uint64, index: number) => void,
+  callback: (id: bigint, index: number) => void,
 ) {
   if (queryResult === undefined) return;
   const { explicitIds } = queryResult;
@@ -1289,9 +1259,7 @@ export function forEachQueryResultSegmentId(
     const { ids } = db!.segmentPropertyMap.inlineProperties!;
     for (let i = 0, count = indices.length; i < count; ++i) {
       const propIndex = indices[i];
-      tempUint64.low = ids[propIndex * 2];
-      tempUint64.high = ids[propIndex * 2 + 1];
-      callback(tempUint64, i);
+      callback(ids[propIndex], i);
     }
   }
 }
@@ -1299,8 +1267,7 @@ export function forEachQueryResultSegmentId(
 export function* forEachQueryResultSegmentIdGenerator(
   db: PreprocessedSegmentPropertyMap | undefined,
   queryResult: QueryResult | undefined,
-  safe = false,
-): IterableIterator<Uint64> {
+): IterableIterator<bigint> {
   if (queryResult === undefined) return;
   const { explicitIds } = queryResult;
   if (explicitIds !== undefined) {
@@ -1313,13 +1280,7 @@ export function* forEachQueryResultSegmentIdGenerator(
     const { ids } = db!.segmentPropertyMap.inlineProperties!;
     for (let i = 0, count = indices.length; i < count; ++i) {
       const propIndex = indices[i];
-      if (safe) {
-        yield new Uint64(ids[propIndex * 2], ids[propIndex * 2 + 1]);
-      } else {
-        tempUint64.low = ids[propIndex * 2];
-        tempUint64.high = ids[propIndex * 2 + 1];
-        yield tempUint64;
-      }
+      yield ids[propIndex];
     }
   }
 }
diff --git a/src/segmentation_graph/local.spec.ts b/src/segmentation_graph/local.spec.ts
index cf9508c64b..5e3d907c40 100644
--- a/src/segmentation_graph/local.spec.ts
+++ b/src/segmentation_graph/local.spec.ts
@@ -17,37 +17,26 @@
 import { describe, it, expect } from "vitest";
 
 import { LocalSegmentationGraphSource } from "#src/segmentation_graph/local.js";
-import { Uint64 } from "#src/util/uint64.js";
-
-function uint64Tester(a: unknown, b: unknown): boolean | undefined {
-  if (a instanceof Uint64 && b instanceof Uint64) {
-    return Uint64.equal(a, b);
-  }
-  return undefined;
-}
-expect.addEqualityTesters([uint64Tester]);
-
-const u64 = (x: string | number) => Uint64.parseString(x.toString());
 
 describe("LocalSegmentationGraphSource", () => {
   it("merge", async () => {
     const graph = new LocalSegmentationGraphSource();
     {
-      const mergeResult = await graph.merge(u64(1), u64(2));
-      expect(mergeResult).toEqual(u64(1));
+      const mergeResult = await graph.merge(1n, 2n);
+      expect(mergeResult).toEqual(1n);
       expect(graph.toJSON()).toEqual([["1", "2"]]);
     }
     {
-      const mergeResult = await graph.merge(u64(2), u64(3));
-      expect(mergeResult).toEqual(u64(1));
+      const mergeResult = await graph.merge(2n, 3n);
+      expect(mergeResult).toEqual(1n);
       expect(graph.toJSON()).toEqual([
         ["1", "2"],
         ["2", "3"],
       ]);
     }
     {
-      const mergeResult = await graph.merge(u64(1), u64(3));
-      expect(mergeResult).toEqual(u64(1));
+      const mergeResult = await graph.merge(1n, 3n);
+      expect(mergeResult).toEqual(1n);
       expect(graph.toJSON()).toEqual([
         ["1", "2"],
         ["2", "3"],
@@ -61,17 +50,17 @@ describe("LocalSegmentationGraphSource", () => {
       ["2", "3"],
     ]);
     {
-      expect(await graph.computeSplit(u64(1), u64(3))).toEqual({
-        includeBaseSegments: [u64(1), u64(2)],
-        includeRepresentative: u64(1),
-        excludeBaseSegments: [u64(3)],
-        excludeRepresentative: u64(3),
+      expect(await graph.computeSplit(1n, 3n)).toEqual({
+        includeBaseSegments: [1n, 2n],
+        includeRepresentative: 1n,
+        excludeBaseSegments: [3n],
+        excludeRepresentative: 3n,
       });
     }
     {
-      expect(await graph.split(u64(1), u64(3))).toEqual({
-        include: u64(1),
-        exclude: u64(3),
+      expect(await graph.split(1n, 3n)).toEqual({
+        include: 1n,
+        exclude: 3n,
       });
       expect(graph.toJSON()).toEqual([["1", "2"]]);
     }
@@ -85,9 +74,9 @@ describe("LocalSegmentationGraphSource", () => {
       ["3", "5"],
     ]);
     {
-      expect(await graph.split(u64(1), u64(3))).toEqual({
-        include: u64(1),
-        exclude: u64(3),
+      expect(await graph.split(1n, 3n)).toEqual({
+        include: 1n,
+        exclude: 3n,
       });
       expect(graph.toJSON()).toEqual([
         ["1", "2"],
diff --git a/src/segmentation_graph/local.ts b/src/segmentation_graph/local.ts
index 8164c6ce78..5a0bc6f19e 100644
--- a/src/segmentation_graph/local.ts
+++ b/src/segmentation_graph/local.ts
@@ -24,32 +24,32 @@ import {
 } from "#src/segmentation_graph/source.js";
 import { SharedDisjointUint64Sets } from "#src/shared_disjoint_sets.js";
 import type { Uint64Set } from "#src/uint64_set.js";
+import { bigintCompare } from "#src/util/bigint.js";
 import { DisjointUint64Sets } from "#src/util/disjoint_sets.js";
-import { parseArray } from "#src/util/json.js";
+import { parseArray, parseUint64 } from "#src/util/json.js";
 import { Signal } from "#src/util/signal.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 export class LocalSegmentationGraphSource extends SegmentationGraphSource {
-  spanningTreeEdges = new Map<string, Set<string>>();
+  spanningTreeEdges = new Map<bigint, Set<bigint>>();
   equivalences = new SharedDisjointUint64Sets();
   connections = new Set<LocalSegmentationGraphSourceConnection>();
   changed = new Signal();
 
-  private link(a: Uint64, b: Uint64) {
+  private link(a: bigint, b: bigint) {
     this.equivalences.link(a, b);
     for (const connection of this.connections) {
       connection.segmentsState.segmentEquivalences.link(a, b);
     }
   }
 
-  private linkAll(ids: Uint64[]) {
+  private linkAll(ids: bigint[]) {
     this.equivalences.linkAll(ids);
     for (const connection of this.connections) {
       connection.segmentsState.segmentEquivalences.linkAll(ids);
     }
   }
 
-  private deleteSet(a: Uint64) {
+  private deleteSet(a: bigint) {
     this.equivalences.deleteSet(a);
     for (const connection of this.connections) {
       connection.segmentsState.segmentEquivalences.deleteSet(a);
@@ -65,48 +65,40 @@ export class LocalSegmentationGraphSource extends SegmentationGraphSource {
     }
   }
 
-  private addSpanningTreeEdge(a: Uint64, b: Uint64) {
-    const aString = a.toString();
-    const bString = b.toString();
+  private addSpanningTreeEdge(a: bigint, b: bigint) {
     const { spanningTreeEdges } = this;
-    let aEdges = spanningTreeEdges.get(aString);
+    let aEdges = spanningTreeEdges.get(a);
     if (aEdges === undefined) {
       aEdges = new Set();
-      spanningTreeEdges.set(aString, aEdges);
+      spanningTreeEdges.set(a, aEdges);
     }
-    let bEdges = spanningTreeEdges.get(bString);
+    let bEdges = spanningTreeEdges.get(b);
     if (bEdges === undefined) {
       bEdges = new Set();
-      spanningTreeEdges.set(bString, bEdges);
+      spanningTreeEdges.set(b, bEdges);
     }
-    aEdges.add(bString);
-    bEdges.add(aString);
+    aEdges.add(b);
+    bEdges.add(a);
   }
 
-  private removeSpanningTreeEdge(a: Uint64, b: Uint64) {
-    const aString = a.toString();
-    const bString = b.toString();
+  private removeSpanningTreeEdge(a: bigint, b: bigint) {
     const { spanningTreeEdges } = this;
-    const aEdges = spanningTreeEdges.get(aString)!;
-    const bEdges = spanningTreeEdges.get(bString)!;
-    aEdges.delete(bString);
+    const aEdges = spanningTreeEdges.get(a)!;
+    const bEdges = spanningTreeEdges.get(b)!;
+    aEdges.delete(b);
     if (aEdges.size === 0) {
-      spanningTreeEdges.delete(aString);
+      spanningTreeEdges.delete(a);
     }
-    bEdges.delete(aString);
+    bEdges.delete(a);
     if (bEdges.size === 0) {
-      spanningTreeEdges.delete(bString);
+      spanningTreeEdges.delete(b);
     }
   }
 
-  private *getSpanningTreeNeighbors(a: Uint64): IterableIterator<Uint64> {
-    const b = new Uint64();
-    const neighbors = this.spanningTreeEdges.get(a.toString());
+  private *getSpanningTreeNeighbors(a: bigint): IterableIterator<bigint> {
+    const neighbors = this.spanningTreeEdges.get(a);
     if (neighbors === undefined) return;
-    for (const neighborString of neighbors) {
-      b.parseString(neighborString);
-      yield b;
-    }
+    yield* neighbors;
   }
 
   restoreState(obj: unknown) {
@@ -116,15 +108,16 @@ export class LocalSegmentationGraphSource extends SegmentationGraphSource {
     if (obj === undefined) {
       return;
     }
-    const ids = [new Uint64(), new Uint64()];
     parseArray(obj, (groupObj) => {
-      parseArray(groupObj, (s, index) => {
-        ids[index % 2].parseString(String(s), 10);
-        if (index !== 0) {
-          if (equivalences.link(ids[0], ids[1])) {
-            this.addSpanningTreeEdge(ids[0], ids[1]);
+      let prev: bigint | undefined;
+      parseArray(groupObj, (s) => {
+        const id = parseUint64(s);
+        if (prev !== undefined) {
+          if (equivalences.link(prev, id)) {
+            this.addSpanningTreeEdge(prev, id);
           }
         }
+        prev = id;
       });
     });
   }
@@ -132,18 +125,14 @@ export class LocalSegmentationGraphSource extends SegmentationGraphSource {
   toJSON() {
     const { spanningTreeEdges } = this;
     if (spanningTreeEdges.size === 0) return undefined;
-    const sets = new Array<Uint64[]>();
-    for (const [idString, neighbors] of spanningTreeEdges) {
-      const a = Uint64.parseString(idString);
-      for (const neighborString of neighbors) {
-        const b = Uint64.parseString(neighborString);
-        if (Uint64.compare(a, b) > 0) continue;
+    const sets = new Array<bigint[]>();
+    for (const [a, neighbors] of spanningTreeEdges) {
+      for (const b of neighbors) {
+        if (a > b) continue;
         sets.push([a, b]);
       }
     }
-    sets.sort(
-      (a, b) => Uint64.compare(a[0], b[0]) || Uint64.compare(a[1], b[1]),
-    );
+    sets.sort((a, b) => bigintCompare(a[0], b[0]) || bigintCompare(a[1], b[1]));
     return sets.map((set) => set.map((element) => element.toString()));
   }
 
@@ -151,9 +140,9 @@ export class LocalSegmentationGraphSource extends SegmentationGraphSource {
     return VisibleSegmentEquivalencePolicy.MIN_REPRESENTATIVE;
   }
 
-  async merge(a: Uint64, b: Uint64): Promise<Uint64> {
+  async merge(a: bigint, b: bigint): Promise<bigint> {
     const { equivalences } = this;
-    if (Uint64.equal(equivalences.get(a), equivalences.get(b))) {
+    if (equivalences.get(a) === equivalences.get(b)) {
       // Already merged.
       return a;
     }
@@ -165,9 +154,9 @@ export class LocalSegmentationGraphSource extends SegmentationGraphSource {
   }
 
   async split(
-    a: Uint64,
-    b: Uint64,
-  ): Promise<{ include: Uint64; exclude: Uint64 }> {
+    a: bigint,
+    b: bigint,
+  ): Promise<{ include: bigint; exclude: bigint }> {
     const result = this.computeSplit(a, b);
     if (result === undefined) {
       throw new Error("Segments are already split");
@@ -182,10 +171,10 @@ export class LocalSegmentationGraphSource extends SegmentationGraphSource {
     this.deleteSet(a);
     this.linkAll(includeBaseSegments);
     this.linkAll(excludeBaseSegments);
-    const removeSplitEdges = (segments: Uint64[], expectedRoot: Uint64) => {
+    const removeSplitEdges = (segments: bigint[], expectedRoot: bigint) => {
       for (const id of segments) {
         for (const neighbor of this.getSpanningTreeNeighbors(id)) {
-          if (!Uint64.equal(equivalences.get(neighbor), expectedRoot)) {
+          if (equivalences.get(neighbor) !== expectedRoot) {
             this.removeSpanningTreeEdge(id, neighbor);
           }
         }
@@ -208,46 +197,48 @@ export class LocalSegmentationGraphSource extends SegmentationGraphSource {
     return { include: includeRoot, exclude: excludeRoot };
   }
 
-  trackSegment(id: Uint64, callback: (id: Uint64 | null) => void): () => void {
+  trackSegment(id: bigint, callback: (id: bigint | null) => void): () => void {
     // FIXME: implement
     id;
     callback;
     return () => {};
   }
 
-  computeSplit(include: Uint64, exclude: Uint64): ComputedSplit | undefined {
+  computeSplit(include: bigint, exclude: bigint): ComputedSplit | undefined {
     const { equivalences } = this;
     const root = equivalences.get(include);
-    if (!Uint64.equal(root, equivalences.get(exclude))) {
+    if (root !== equivalences.get(exclude)) {
       // Already split.
       return undefined;
     }
     const ds = new DisjointUint64Sets();
     for (const baseSegment of equivalences.setElements(root)) {
-      if (Uint64.equal(baseSegment, exclude)) continue;
+      if (baseSegment === exclude) continue;
       for (const neighbor of this.getSpanningTreeNeighbors(baseSegment)) {
-        if (Uint64.equal(neighbor, exclude)) continue;
+        if (neighbor === exclude) continue;
         ds.link(baseSegment, neighbor);
       }
     }
-    const includeSegments: Uint64[] = [];
-    const excludeSegments: Uint64[] = [];
+    const includeSegments: bigint[] = [];
+    const excludeSegments: bigint[] = [];
     const includeRoot = ds.get(include);
     let includeRep = include;
     let excludeRep = exclude;
     for (const baseSegment of equivalences.setElements(root)) {
-      if (Uint64.equal(ds.get(baseSegment), includeRoot)) {
+      if (ds.get(baseSegment) === includeRoot) {
         includeSegments.push(baseSegment);
-        if (Uint64.compare(baseSegment, includeRep) < 0)
+        if (baseSegment < includeRep) {
           includeRep = baseSegment;
+        }
       } else {
         excludeSegments.push(baseSegment);
-        if (Uint64.compare(baseSegment, excludeRep) < 0)
+        if (baseSegment < excludeRep) {
           excludeRep = baseSegment;
+        }
       }
     }
-    includeSegments.sort(Uint64.compare);
-    excludeSegments.sort(Uint64.compare);
+    includeSegments.sort(bigintCompare);
+    excludeSegments.sort(bigintCompare);
     return {
       includeBaseSegments: includeSegments,
       includeRepresentative: includeRep,
@@ -293,10 +284,10 @@ function normalizeSegmentSet(
   segmentSet: Uint64Set,
   equivalences: DisjointUint64Sets,
 ) {
-  const add: Uint64[] = [];
-  for (const id of segmentSet.unsafeKeys()) {
+  const add: bigint[] = [];
+  for (const id of segmentSet.keys()) {
     const rootId = equivalences.get(id);
-    if (!Uint64.equal(id, rootId)) {
+    if (id !== rootId) {
       add.push(rootId);
       segmentSet.delete(id);
     }
@@ -307,7 +298,7 @@ function normalizeSegmentSet(
 }
 
 class LocalSegmentationGraphSourceConnection extends SegmentationGraphSourceConnection<LocalSegmentationGraphSource> {
-  computeSplit(include: Uint64, exclude: Uint64): ComputedSplit | undefined {
+  computeSplit(include: bigint, exclude: bigint): ComputedSplit | undefined {
     return this.graph.computeSplit(include, exclude);
   }
 }
diff --git a/src/segmentation_graph/segment_id.ts b/src/segmentation_graph/segment_id.ts
index 5f3e55bc57..2068e4da74 100644
--- a/src/segmentation_graph/segment_id.ts
+++ b/src/segmentation_graph/segment_id.ts
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import { Uint64 } from "#src/util/uint64.js";
-
 export enum VisibleSegmentEquivalencePolicy {
   MIN_REPRESENTATIVE = 0, // defafult, representative elmement is the minimum element in equivalence set
   MAX_REPRESENTATIVE = 1, // representative elmement is the maximum element in equivalence set
@@ -24,8 +22,8 @@ export enum VisibleSegmentEquivalencePolicy {
 }
 
 // Returns `true` if `segmentId` is a base segment id, rather than a segment id added to the graph.
-export function isBaseSegmentId(segmentId: Uint64) {
-  return segmentId.high >>> 31 ? false : true;
+export function isBaseSegmentId(segmentId: bigint) {
+  return segmentId & 0x8000000000000000n ? false : true;
 }
 
-export const UNKNOWN_NEW_SEGMENT_ID = new Uint64(0xffffffff, 0xffffffff);
+export const UNKNOWN_NEW_SEGMENT_ID = 0xffffffffffffffffn;
diff --git a/src/segmentation_graph/source.ts b/src/segmentation_graph/source.ts
index ab8d6a1742..42e89e770f 100644
--- a/src/segmentation_graph/source.ts
+++ b/src/segmentation_graph/source.ts
@@ -23,7 +23,6 @@ import type { VisibleSegmentEquivalencePolicy } from "#src/segmentation_graph/se
 import type { WatchableValueInterface } from "#src/trackable_value.js";
 import type { Disposer, Owned } from "#src/util/disposable.js";
 import { RefCounted } from "#src/util/disposable.js";
-import { Uint64 } from "#src/util/uint64.js";
 import type { DependentViewContext } from "#src/widget/dependent_view_widget.js";
 import { DependentViewWidget } from "#src/widget/dependent_view_widget.js";
 import { Tab } from "#src/widget/tab_view.js";
@@ -51,14 +50,14 @@ export abstract class SegmentationGraphSource {
   abstract connect(
     layer: SegmentationUserLayer,
   ): Owned<SegmentationGraphSourceConnection>;
-  abstract merge(a: Uint64, b: Uint64): Promise<Uint64>;
+  abstract merge(a: bigint, b: bigint): Promise<bigint>;
   abstract split(
-    include: Uint64,
-    exclude: Uint64,
-  ): Promise<{ include: Uint64; exclude: Uint64 }>;
+    include: bigint,
+    exclude: bigint,
+  ): Promise<{ include: bigint; exclude: bigint }>;
   abstract trackSegment(
-    id: Uint64,
-    callback: (id: Uint64 | null) => void,
+    id: bigint,
+    callback: (id: bigint | null) => void,
   ): () => void;
   abstract get visibleSegmentEquivalencePolicy(): VisibleSegmentEquivalencePolicy;
   tabContents?(
@@ -70,13 +69,13 @@ export abstract class SegmentationGraphSource {
 
 export interface ComputedSplit {
   // New representative id of retained segment.  May be fake.
-  includeRepresentative: Uint64;
+  includeRepresentative: bigint;
   // Base segment ids in retained segment.
-  includeBaseSegments: Uint64[];
+  includeBaseSegments: bigint[];
   // New representative id of split-off segment.  May be fake.
-  excludeRepresentative: Uint64;
+  excludeRepresentative: bigint;
   // Base segments in split-off segment.
-  excludeBaseSegments: Uint64[];
+  excludeBaseSegments: bigint[];
 }
 
 export abstract class SegmentationGraphSourceConnection<
@@ -89,8 +88,8 @@ export abstract class SegmentationGraphSourceConnection<
     super();
   }
   abstract computeSplit(
-    include: Uint64,
-    exclude: Uint64,
+    include: bigint,
+    exclude: bigint,
   ): ComputedSplit | undefined;
 
   createRenderLayers(
@@ -107,9 +106,9 @@ export abstract class SegmentationGraphSourceConnection<
 
 export function trackWatchableValueSegment(
   graph: SegmentationGraphSource,
-  watchable: WatchableValueInterface<Uint64 | undefined>,
+  watchable: WatchableValueInterface<bigint | undefined>,
 ): Disposer {
-  let lastId: Uint64 | null | undefined;
+  let lastId: bigint | null | undefined;
   let watchDisposer: undefined | (() => void) = undefined;
   const handleLocalChange = () => {
     const { value } = watchable;
@@ -121,7 +120,7 @@ export function trackWatchableValueSegment(
       }
       return;
     }
-    if (lastId != null && Uint64.equal(lastId, value)) {
+    if (lastId != null && lastId === value) {
       return;
     }
     if (watchDisposer !== undefined) {
diff --git a/src/shared_disjoint_sets.ts b/src/shared_disjoint_sets.ts
index 0f6b24a0f0..c40725eda8 100644
--- a/src/shared_disjoint_sets.ts
+++ b/src/shared_disjoint_sets.ts
@@ -17,9 +17,8 @@
 import type { VisibleSegmentEquivalencePolicy } from "#src/segmentation_graph/segment_id.js";
 import type { WatchableValueInterface } from "#src/trackable_value.js";
 import { DisjointUint64Sets } from "#src/util/disjoint_sets.js";
-import { parseArray } from "#src/util/json.js";
+import { parseArray, parseUint64 } from "#src/util/json.js";
 import { NullarySignal } from "#src/util/signal.js";
-import { Uint64 } from "#src/util/uint64.js";
 import type { RPC } from "#src/worker_rpc.js";
 import {
   registerRPC,
@@ -67,16 +66,14 @@ export class SharedDisjointUint64Sets
     return obj;
   }
 
-  link(a: Uint64, b: Uint64) {
+  link(a: bigint, b: bigint) {
     if (this.disjointSets.link(a, b)) {
       const { rpc } = this;
       if (rpc) {
         rpc.invoke(ADD_METHOD_ID, {
           id: this.rpcId,
-          al: a.low,
-          ah: a.high,
-          bl: b.low,
-          bh: b.high,
+          a: a,
+          b: b,
         });
       }
       this.changed.dispatch();
@@ -85,17 +82,17 @@ export class SharedDisjointUint64Sets
     return false;
   }
 
-  linkAll(ids: Uint64[]) {
+  linkAll(ids: bigint[]) {
     for (let i = 1, length = ids.length; i < length; ++i) {
       this.link(ids[0], ids[i]);
     }
   }
 
-  has(x: Uint64): boolean {
+  has(x: bigint): boolean {
     return this.disjointSets.has(x);
   }
 
-  get(x: Uint64): Uint64 {
+  get(x: bigint): bigint {
     return this.disjointSets.get(x);
   }
 
@@ -109,18 +106,17 @@ export class SharedDisjointUint64Sets
     }
   }
 
-  setElements(a: Uint64) {
+  setElements(a: bigint) {
     return this.disjointSets.setElements(a);
   }
 
-  deleteSet(x: Uint64) {
+  deleteSet(x: bigint) {
     if (this.disjointSets.deleteSet(x)) {
       const { rpc } = this;
       if (rpc) {
         rpc.invoke(DELETE_SET_METHOD_ID, {
           id: this.rpcId,
-          l: x.low,
-          h: x.high,
+          x,
         });
       }
       this.changed.dispatch();
@@ -140,13 +136,14 @@ export class SharedDisjointUint64Sets
    */
   restoreState(obj: any) {
     if (obj !== undefined) {
-      const ids = [new Uint64(), new Uint64()];
       parseArray(obj, (z) => {
-        parseArray(z, (s, index) => {
-          ids[index % 2].parseString(String(s), 10);
-          if (index !== 0) {
-            this.link(ids[0], ids[1]);
+        let prev: bigint | undefined;
+        parseArray(z, (s) => {
+          const cur = parseUint64(s);
+          if (prev !== undefined) {
+            this.link(prev, cur);
           }
+          prev = cur;
         });
       });
     }
@@ -163,16 +160,9 @@ export class SharedDisjointUint64Sets
   }
 }
 
-const tempA = new Uint64();
-const tempB = new Uint64();
-
 registerRPC(ADD_METHOD_ID, function (x) {
   const obj = <SharedDisjointUint64Sets>this.get(x.id);
-  tempA.low = x.al;
-  tempA.high = x.ah;
-  tempB.low = x.bl;
-  tempB.high = x.bh;
-  if (obj.disjointSets.link(tempA, tempB)) {
+  if (obj.disjointSets.link(x.a, x.b)) {
     obj.changed.dispatch();
   }
 });
@@ -198,9 +188,7 @@ registerRPC(HIGH_BIT_REPRESENTATIVE_CHANGED_ID, function (x) {
 
 registerRPC(DELETE_SET_METHOD_ID, function (x) {
   const obj = <SharedDisjointUint64Sets>this.get(x.id);
-  tempA.low = x.l;
-  tempA.high = x.h;
-  if (obj.disjointSets.deleteSet(tempA)) {
+  if (obj.disjointSets.deleteSet(x.x)) {
     obj.changed.dispatch();
   }
 });
diff --git a/src/skeleton/backend.ts b/src/skeleton/backend.ts
index 60bd5cccf0..85cbc710bd 100644
--- a/src/skeleton/backend.ts
+++ b/src/skeleton/backend.ts
@@ -30,7 +30,6 @@ import {
 import { SKELETON_LAYER_RPC_ID } from "#src/skeleton/base.js";
 import type { TypedNumberArray } from "#src/util/array.js";
 import type { Endianness } from "#src/util/endian.js";
-import { Uint64 } from "#src/util/uint64.js";
 import {
   getBasePriority,
   getPriorityTier,
@@ -43,14 +42,14 @@ const SKELETON_CHUNK_PRIORITY = 60;
 
 // Chunk that contains the skeleton of a single object.
 export class SkeletonChunk extends Chunk {
-  objectId = new Uint64();
+  objectId: bigint = 0n;
   vertexPositions: Float32Array | null = null;
   vertexAttributes: TypedNumberArray[] | null = null;
   indices: Uint32Array | null = null;
 
-  initializeSkeletonChunk(key: string, objectId: Uint64) {
+  initializeSkeletonChunk(key: string, objectId: bigint) {
     super.initialize(key);
-    this.objectId.assign(objectId);
+    this.objectId = objectId;
   }
   freeSystemMemory() {
     this.vertexPositions = this.indices = null;
@@ -121,7 +120,7 @@ export class SkeletonChunk extends Chunk {
 
 export class SkeletonSource extends ChunkSource {
   declare chunks: Map<string, SkeletonChunk>;
-  getChunk(objectId: Uint64) {
+  getChunk(objectId: bigint) {
     const key = getObjectKey(objectId);
     let chunk = this.chunks.get(key);
     if (chunk === undefined) {
diff --git a/src/sliceview/compressed_segmentation/chunk_format.ts b/src/sliceview/compressed_segmentation/chunk_format.ts
index 24bbfd49b1..b025c49720 100644
--- a/src/sliceview/compressed_segmentation/chunk_format.ts
+++ b/src/sliceview/compressed_segmentation/chunk_format.ts
@@ -29,7 +29,6 @@ import type {
 import { registerChunkFormatHandler } from "#src/sliceview/volume/frontend.js";
 import { RefCounted } from "#src/util/disposable.js";
 import { vec3, vec3Key } from "#src/util/geom.js";
-import { Uint64 } from "#src/util/uint64.js";
 import type { GL } from "#src/webgl/context.js";
 import type {
   ShaderBuilder,
@@ -312,7 +311,7 @@ export class CompressedSegmentationVolumeChunk extends SingleTextureVolumeChunk<
     chunkFormat.setTextureData(gl, textureLayout, data!);
   }
 
-  getValueAt(dataPosition: Uint32Array): Uint64 | number {
+  getValueAt(dataPosition: Uint32Array): bigint | number {
     const { chunkDataSize, chunkFormat } = this;
     const { data } = this;
     if (data === null) {
@@ -320,14 +319,12 @@ export class CompressedSegmentationVolumeChunk extends SingleTextureVolumeChunk<
     }
     const offset = data[dataPosition[3] || 0];
     if (chunkFormat.dataType === DataType.UINT64) {
-      return Uint64.fromBigInt(
-        readSingleChannelValueUint64(
-          data,
-          /*baseOffset=*/ offset,
-          chunkDataSize,
-          chunkFormat.subchunkSize,
-          dataPosition,
-        ),
+      return readSingleChannelValueUint64(
+        data,
+        /*baseOffset=*/ offset,
+        chunkDataSize,
+        chunkFormat.subchunkSize,
+        dataPosition,
       );
     }
     return readSingleChannelValueUint32(
@@ -348,7 +345,7 @@ class FillValueChunk extends RefCounted {
 function getFillValueChunk(
   gl: GL,
   chunkFormat: ChunkFormat,
-  fillValue: number | Uint64,
+  fillValue: number | bigint,
 ): FillValueChunk {
   const { dataType, numChannels } = chunkFormat;
   const array = new Uint32Array(
@@ -357,8 +354,8 @@ function getFillValueChunk(
   array[0] = numChannels;
   array[numChannels] = 2;
   if (dataType === DataType.UINT64) {
-    array[numChannels + 2] = (fillValue as Uint64).low;
-    array[numChannels + 3] = (fillValue as Uint64).high;
+    array[numChannels + 2] = Number((fillValue as bigint) & 0xffffffffn);
+    array[numChannels + 3] = Number((fillValue as bigint) >> 32n);
   } else {
     array[numChannels + 2] = fillValue as number;
   }
diff --git a/src/sliceview/single_texture_chunk_format.ts b/src/sliceview/single_texture_chunk_format.ts
index 39449a05b4..53468aedfd 100644
--- a/src/sliceview/single_texture_chunk_format.ts
+++ b/src/sliceview/single_texture_chunk_format.ts
@@ -19,7 +19,7 @@ import type {
   ChunkFormat,
 } from "#src/sliceview/volume/frontend.js";
 import { VolumeChunk } from "#src/sliceview/volume/frontend.js";
-import type { TypedNumberArray } from "#src/util/array.js";
+import type { TypedArray } from "#src/util/array.js";
 import type { DataType } from "#src/util/data_type.js";
 import type { Disposable } from "#src/util/disposable.js";
 import { RefCounted } from "#src/util/disposable.js";
@@ -110,7 +110,7 @@ export abstract class SingleTextureChunkFormat<TextureLayout extends Disposable>
   abstract setTextureData(
     gl: GL,
     textureLayout: TextureLayout,
-    data: TypedNumberArray,
+    data: TypedArray,
   ): void;
 
   /**
diff --git a/src/sliceview/uncompressed_chunk_format.ts b/src/sliceview/uncompressed_chunk_format.ts
index 5ffbbc5255..2f1eadbd71 100644
--- a/src/sliceview/uncompressed_chunk_format.ts
+++ b/src/sliceview/uncompressed_chunk_format.ts
@@ -18,23 +18,21 @@ import {
   SingleTextureChunkFormat,
   SingleTextureVolumeChunk,
 } from "#src/sliceview/single_texture_chunk_format.js";
-import type { VolumeChunkSpecification } from "#src/sliceview/volume/base.js";
-import { DataType } from "#src/sliceview/volume/base.js";
+import type {
+  VolumeChunkSpecification,
+  DataType,
+} from "#src/sliceview/volume/base.js";
 import type {
   ChunkFormatHandler,
   VolumeChunkSource,
 } from "#src/sliceview/volume/frontend.js";
 import { registerChunkFormatHandler } from "#src/sliceview/volume/frontend.js";
 import type {
-  TypedNumberArray,
+  TypedArray,
   TypedNumberArrayConstructor,
 } from "#src/util/array.js";
-import {
-  DATA_TYPE_ARRAY_CONSTRUCTOR,
-  DATA_TYPE_JAVASCRIPT_ELEMENTS_PER_ARRAY_ELEMENT,
-} from "#src/util/data_type.js";
+import { DATA_TYPE_ARRAY_CONSTRUCTOR } from "#src/util/data_type.js";
 import { RefCounted } from "#src/util/disposable.js";
-import { Uint64 } from "#src/util/uint64.js";
 import type { GL } from "#src/webgl/context.js";
 import type {
   ShaderBuilder,
@@ -266,7 +264,7 @@ ${shaderType} getDataValueAt(highp ivec3 p`;
     return TextureLayout.get(gl, chunkDataSize, this.textureDims);
   }
 
-  setTextureData(gl: GL, textureLayout: TextureLayout, data: TypedNumberArray) {
+  setTextureData(gl: GL, textureLayout: TextureLayout, data: TypedArray) {
     const { textureShape } = textureLayout;
     (this.textureDims === 3
       ? setThreeDimensionalTextureData
@@ -286,7 +284,7 @@ interface Source extends VolumeChunkSource {
 }
 
 export class UncompressedVolumeChunk extends SingleTextureVolumeChunk<
-  Uint8Array,
+  TypedArray,
   TextureLayout
 > {
   declare CHUNK_FORMAT_TYPE: ChunkFormat;
@@ -310,12 +308,11 @@ export class UncompressedVolumeChunk extends SingleTextureVolumeChunk<
     this.chunkFormat.setTextureData(gl, textureLayout, this.data!);
   }
 
-  getValueAt(dataPosition: Uint32Array): number | Uint64 {
+  getValueAt(dataPosition: Uint32Array): number | bigint {
     const { data } = this;
     if (data === null) {
       return this.source.spec.fillValue;
     }
-    const { chunkFormat } = this;
     const { chunkDataSize } = this;
     let index = 0;
     let stride = 1;
@@ -324,21 +321,7 @@ export class UncompressedVolumeChunk extends SingleTextureVolumeChunk<
       index += stride * dataPosition[i];
       stride *= chunkDataSize[i];
     }
-    const dataType = chunkFormat.dataType;
-    switch (dataType) {
-      case DataType.UINT8:
-      case DataType.INT8:
-      case DataType.FLOAT32:
-      case DataType.UINT16:
-      case DataType.INT16:
-      case DataType.UINT32:
-      case DataType.INT32:
-        return data[index];
-      case DataType.UINT64: {
-        const index2 = index * 2;
-        return new Uint64(data[index2], data[index2 + 1]);
-      }
-    }
+    return data[index];
   }
 }
 
@@ -349,26 +332,15 @@ class FillValueChunk extends RefCounted {
 
 export function getFillValueArray(
   dataType: DataType,
-  fillValue: number | Uint64,
+  fillValue: number | bigint,
 ) {
-  const array = new (DATA_TYPE_ARRAY_CONSTRUCTOR[
-    dataType
-  ] as TypedNumberArrayConstructor<ArrayBuffer>)(
-    DATA_TYPE_JAVASCRIPT_ELEMENTS_PER_ARRAY_ELEMENT[dataType],
-  );
-  if (dataType === DataType.UINT64) {
-    array[0] = (fillValue as Uint64).low;
-    array[1] = (fillValue as Uint64).high;
-  } else {
-    array[0] = fillValue as number;
-  }
-  return array;
+  return (DATA_TYPE_ARRAY_CONSTRUCTOR[dataType] as any).of(fillValue);
 }
 
 function getFillValueChunk(
   gl: GL,
   chunkFormat: ChunkFormat,
-  fillValue: number | Uint64,
+  fillValue: number | bigint,
   rank: number,
   textureDims: number,
 ): FillValueChunk {
diff --git a/src/sliceview/volume/base.ts b/src/sliceview/volume/base.ts
index a81019c56f..583d8653e7 100644
--- a/src/sliceview/volume/base.ts
+++ b/src/sliceview/volume/base.ts
@@ -31,7 +31,6 @@ import { DATA_TYPE_BYTES, DataType } from "#src/util/data_type.js";
 import type { vec3 } from "#src/util/geom.js";
 import { getDependentTransformInputDimensions } from "#src/util/geom.js";
 import * as matrix from "#src/util/matrix.js";
-import { Uint64 } from "#src/util/uint64.js";
 import * as vector from "#src/util/vector.js";
 
 export { DATA_TYPE_BYTES, DataType };
@@ -76,7 +75,7 @@ export interface VolumeChunkSpecificationBaseOptions
    */
   baseVoxelOffset?: Float32Array;
   dataType: DataType;
-  fillValue?: number | Uint64;
+  fillValue?: number | bigint;
 
   /**
    * If set, indicates that the chunk is in compressed segmentation format with the specified block
@@ -132,7 +131,7 @@ export interface VolumeChunkSpecification
   baseVoxelOffset: Float32Array;
   dataType: DataType;
   compressedSegmentationBlockSize: vec3 | undefined;
-  fillValue: number | Uint64;
+  fillValue: number | bigint;
 }
 
 export function makeVolumeChunkSpecification(
@@ -141,7 +140,7 @@ export function makeVolumeChunkSpecification(
   const {
     rank,
     dataType,
-    fillValue = dataType === DataType.UINT64 ? Uint64.ZERO : 0,
+    fillValue = dataType === DataType.UINT64 ? 0n : 0,
     compressedSegmentationBlockSize,
   } = options;
   const { baseVoxelOffset = new Float32Array(rank) } = options;
diff --git a/src/sliceview/volume/segmentation_renderlayer.ts b/src/sliceview/volume/segmentation_renderlayer.ts
index d2da8376fe..c4a6c44b16 100644
--- a/src/sliceview/volume/segmentation_renderlayer.ts
+++ b/src/sliceview/volume/segmentation_renderlayer.ts
@@ -359,8 +359,8 @@ uint64_t getMappedObjectId(uint64_t value) {
       const seg = displayState.baseSegmentHighlighting.value
         ? segmentSelectionState.baseSelectedSegment
         : segmentSelectionState.selectedSegment;
-      selectedSegmentLow = seg.low;
-      selectedSegmentHigh = seg.high;
+      selectedSegmentLow = Number(seg & 0xffffffffn);
+      selectedSegmentHigh = Number(seg >> 32n);
       flags |= HAS_SELECTED_SEGMENT_FLAG;
     }
     gl.uniform1f(
diff --git a/src/ui/annotations.ts b/src/ui/annotations.ts
index 6744105eaf..c25be4c47d 100644
--- a/src/ui/annotations.ts
+++ b/src/ui/annotations.ts
@@ -89,6 +89,7 @@ import { removeChildren } from "#src/util/dom.js";
 import { Endianness, ENDIANNESS } from "#src/util/endian.js";
 import type { ValueOrError } from "#src/util/error.js";
 import { vec3 } from "#src/util/geom.js";
+import { parseUint64 } from "#src/util/json.js";
 import {
   EventActionMap,
   KeyboardEventBinder,
@@ -98,7 +99,6 @@ import * as matrix from "#src/util/matrix.js";
 import { MouseEventBinder } from "#src/util/mouse_bindings.js";
 import { formatScaleWithUnitAsString } from "#src/util/si_units.js";
 import { NullarySignal, Signal } from "#src/util/signal.js";
-import { Uint64 } from "#src/util/uint64.js";
 import * as vector from "#src/util/vector.js";
 import { makeAddButton } from "#src/widget/add_button.js";
 import { ColorWidget } from "#src/widget/color.js";
@@ -985,8 +985,8 @@ export class AnnotationTab extends Tab {
 function getSelectedAssociatedSegments(
   annotationLayer: AnnotationLayerState,
   getBase = false,
-) {
-  const segments: Uint64[][] = [];
+): BigUint64Array[] {
+  const segments: bigint[][] = [];
   const { relationships } = annotationLayer.source;
   const { relationshipStates } = annotationLayer.displayState;
   for (let i = 0, count = relationships.length; i < count; ++i) {
@@ -994,13 +994,11 @@ function getSelectedAssociatedSegments(
       .segmentationState.value;
     if (segmentationState != null) {
       if (segmentationState.segmentSelectionState.hasSelectedSegment) {
-        segments[i] = [
-          segmentationState.segmentSelectionState.selectedSegment.clone(),
-        ];
+        segments[i] = [segmentationState.segmentSelectionState.selectedSegment];
         if (getBase) {
           segments[i] = [
             ...segments[i],
-            segmentationState.segmentSelectionState.baseSelectedSegment.clone(),
+            segmentationState.segmentSelectionState.baseSelectedSegment,
           ];
         }
         continue;
@@ -1008,7 +1006,7 @@ function getSelectedAssociatedSegments(
     }
     segments[i] = [];
   }
-  return segments;
+  return segments.map((x) => BigUint64Array.from(x));
 }
 
 abstract class PlaceAnnotationTool extends LegacyTool {
@@ -1259,7 +1257,7 @@ export class PlaceLineTool extends PlaceTwoCornerAnnotationTool {
     return "annotate line";
   }
 
-  private initialRelationships: Uint64[][] | undefined;
+  private initialRelationships: BigUint64Array[] | undefined;
 
   getInitialAnnotation(
     mouseState: MouseSelectionState,
@@ -1293,10 +1291,8 @@ export class PlaceLineTool extends PlaceTwoCornerAnnotationTool {
         newRelationships,
         (newSegments, i) => {
           const initialSegments = initialRelationships[i];
-          newSegments = newSegments.filter(
-            (x) => initialSegments.findIndex((y) => Uint64.equal(x, y)) === -1,
-          );
-          return [...initialSegments, ...newSegments];
+          newSegments = newSegments.filter((x) => !initialSegments.includes(x));
+          return BigUint64Array.from([...initialSegments, ...newSegments]);
         },
       );
     }
@@ -1387,11 +1383,11 @@ const newRelatedSegmentKeyMap = EventActionMap.fromObject({
 
 function makeRelatedSegmentList(
   listName: string,
-  segments: Uint64[],
+  segments: BigUint64Array,
   segmentationDisplayState: WatchableValueInterface<
     SegmentationDisplayState | null | undefined
   >,
-  mutate?: ((newSegments: Uint64[]) => void) | undefined,
+  mutate?: ((newSegments: BigUint64Array) => void) | undefined,
 ) {
   return new DependentViewWidget(
     segmentationDisplayState,
@@ -1408,7 +1404,7 @@ function makeRelatedSegmentList(
       const copyButton = makeCopyButton({
         title: "Copy segment IDs",
         onClick: () => {
-          setClipboard(segments.map((x) => x.toString()).join(", "));
+          setClipboard(Array.from(segments, (x) => x.toString()).join(", "));
         },
       });
       headerRow.appendChild(copyButton);
@@ -1430,7 +1426,7 @@ function makeRelatedSegmentList(
         const deleteButton = makeDeleteButton({
           title: "Remove all IDs",
           onClick: () => {
-            mutate([]);
+            mutate(new BigUint64Array(0));
           },
         });
         headerRow.appendChild(deleteButton);
@@ -1480,13 +1476,14 @@ function makeRelatedSegmentList(
             );
             keyboardEventBinder.allShortcutsAreGlobal = true;
             const validateInput = () => {
-              const id = new Uint64();
-              if (id.tryParseString(idElement.value)) {
+              try {
+                const id = parseUint64(idElement.value);
                 idElement.dataset.valid = "true";
                 return id;
+              } catch {
+                idElement.dataset.valid = "false";
+                return undefined;
               }
-              idElement.dataset.valid = "false";
-              return undefined;
             };
             validateInput();
             idElement.addEventListener("input", () => {
@@ -1495,7 +1492,7 @@ function makeRelatedSegmentList(
             idElement.addEventListener("blur", () => {
               const id = validateInput();
               if (id !== undefined) {
-                mutate([...segments, id]);
+                mutate(BigUint64Array.from([...segments, id]));
               }
               addContextDisposer();
             });
@@ -1503,7 +1500,7 @@ function makeRelatedSegmentList(
             registerActionListener(idElement, "commit", () => {
               const id = validateInput();
               if (id !== undefined) {
-                mutate([...segments, id]);
+                mutate(BigUint64Array.from([...segments, id]));
               }
               addContextDisposer();
             });
@@ -1533,7 +1530,7 @@ function makeRelatedSegmentList(
           const deleteButton = makeDeleteButton({
             title: "Remove ID",
             onClick: (event) => {
-              mutate(segments.filter((x) => !Uint64.equal(x, id)));
+              mutate(segments.filter((x) => x !== id));
               event.stopPropagation();
             },
           });
@@ -1929,7 +1926,9 @@ export function UserLayerWithAnnotationsMixin<
                 const { relatedSegments } = annotation;
                 for (let i = 0, count = relationships.length; i < count; ++i) {
                   const related =
-                    relatedSegments === undefined ? [] : relatedSegments[i];
+                    relatedSegments === undefined
+                      ? new BigUint64Array(0)
+                      : relatedSegments[i];
                   if (related.length === 0 && sourceReadonly) continue;
                   const relationshipIndex = i;
                   const relationship = relationships[i];
@@ -1952,7 +1951,7 @@ export function UserLayerWithAnnotationsMixin<
                               if (relatedSegments === undefined) {
                                 relatedSegments =
                                   annotationLayer.source.relationships.map(
-                                    () => [],
+                                    () => new BigUint64Array(0),
                                   );
                               } else {
                                 relatedSegments = relatedSegments.slice();
diff --git a/src/ui/layer_drag_and_drop.ts b/src/ui/layer_drag_and_drop.ts
index 4c3867e671..977e9d1cca 100644
--- a/src/ui/layer_drag_and_drop.ts
+++ b/src/ui/layer_drag_and_drop.ts
@@ -30,6 +30,7 @@ import {
   setDropEffect,
 } from "#src/util/drag_and_drop.js";
 import {
+  bigintToStringJsonReplacer,
   parseArray,
   verifyBoolean,
   verifyObjectProperty,
@@ -64,10 +65,13 @@ export function startLayerDrag(
         visible: layer.visible,
       })),
     ),
-    JSON.stringify({
-      layers: sourceInfo.layers.map((layer) => layer.toJSON()),
-      layout: sourceInfo.layoutSpec,
-    }),
+    JSON.stringify(
+      {
+        layers: sourceInfo.layers.map((layer) => layer.toJSON()),
+        layout: sourceInfo.layoutSpec,
+      },
+      bigintToStringJsonReplacer,
+    ),
   );
   if (dragSource !== undefined) {
     dragSource.disposer();
diff --git a/src/ui/segment_list.ts b/src/ui/segment_list.ts
index 6ae8db3592..70baf94dd0 100644
--- a/src/ui/segment_list.ts
+++ b/src/ui/segment_list.ts
@@ -59,6 +59,7 @@ import { makeToolButton } from "#src/ui/tool.js";
 import { animationFrameDebounce } from "#src/util/animation_frame_debounce.js";
 import type { ArraySpliceOp } from "#src/util/array.js";
 import { getFixedOrderMergeSplices } from "#src/util/array.js";
+import { bigintCompare } from "#src/util/bigint.js";
 import { setClipboard } from "#src/util/clipboard.js";
 import { RefCounted } from "#src/util/disposable.js";
 import { removeChildren, updateInputFieldWidth } from "#src/util/dom.js";
@@ -79,7 +80,6 @@ import {
 } from "#src/util/lerp.js";
 import { MouseEventBinder } from "#src/util/mouse_bindings.js";
 import { neverSignal, NullarySignal, Signal } from "#src/util/signal.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { CheckboxIcon } from "#src/widget/checkbox_icon.js";
 import { makeCopyButton } from "#src/widget/copy_button.js";
 import { DependentViewWidget } from "#src/widget/dependent_view_widget.js";
@@ -94,8 +94,6 @@ import { Tab } from "#src/widget/tab_view.js";
 import type { VirtualListSource } from "#src/widget/virtual_list.js";
 import { VirtualList } from "#src/widget/virtual_list.js";
 
-const tempUint64 = new Uint64();
-
 abstract class SegmentListSource
   extends RefCounted
   implements VirtualListSource
@@ -106,7 +104,7 @@ abstract class SegmentListSource
   // The segment list is the concatenation of two lists: the `explicitSegments` list, specified as
   // explicit uint64 ids, and the `matches`, list, specifying the indices into the
   // `segmentPropertyMap` of the matching segments.
-  explicitSegments: Uint64[] | undefined;
+  explicitSegments: bigint[] | undefined;
 
   debouncedUpdate = debounce(() => this.update(), 0);
 
@@ -165,7 +163,7 @@ class StarredSegmentsListSource extends SegmentListSource {
         ...getFixedOrderMergeSplices(
           explicitSegments,
           newSelectedSegments,
-          Uint64.equal,
+          (a, b) => a === b,
         ),
       );
     }
@@ -334,16 +332,14 @@ class SegmentQueryListSource extends SegmentListSource {
 
   render = (index: number) => {
     const { explicitSegments } = this;
-    let id: Uint64;
+    let id: bigint;
     if (explicitSegments !== undefined) {
       id = explicitSegments[index];
     } else {
-      id = tempUint64;
       const propIndex = this.queryResult.value!.indices![index];
       const { ids } =
         this.segmentPropertyMap!.segmentPropertyMap.inlineProperties!;
-      id.low = ids[propIndex * 2];
-      id.high = ids[propIndex * 2 + 1];
+      id = ids[propIndex];
     }
     return this.segmentWidgetFactory.get(id);
   };
@@ -581,12 +577,11 @@ class NumericalPropertiesSummary extends RefCounted {
     }
     const newWindow = getClampedInterval(property.bounds, value.window);
     const oldValue = this.getBounds(propertyIndex);
-    const { dataType } = this.properties[propertyIndex].property;
-    if (!dataTypeIntervalEqual(dataType, newWindow, oldValue.window)) {
+    if (!dataTypeIntervalEqual(newWindow, oldValue.window)) {
       this.bounds.window.value[propertyIndex] = newWindow;
       this.bounds.window.changed.dispatch();
     }
-    if (!dataTypeIntervalEqual(dataType, newRange, oldValue.range)) {
+    if (!dataTypeIntervalEqual(newRange, oldValue.range)) {
       this.bounds.range.value[propertyIndex] = newRange;
       this.bounds.range.changed.dispatch();
     }
@@ -829,16 +824,8 @@ class NumericalPropertiesSummary extends RefCounted {
     // Check if we need to update the image.
     if (
       summary.propertyHistogram === propertyHistogram &&
-      dataTypeIntervalEqual(
-        property.dataType,
-        prevWindowBounds,
-        windowBounds,
-      ) &&
-      dataTypeIntervalEqual(
-        property.dataType,
-        prevConstraintBounds,
-        constraintBounds,
-      )
+      dataTypeIntervalEqual(prevWindowBounds, windowBounds) &&
+      dataTypeIntervalEqual(prevConstraintBounds, constraintBounds)
     ) {
       return;
     }
@@ -904,13 +891,7 @@ class NumericalPropertiesSummary extends RefCounted {
       }
     }
 
-    if (
-      !dataTypeIntervalEqual(
-        property.dataType,
-        property.bounds,
-        constraintBounds,
-      )
-    ) {
+    if (!dataTypeIntervalEqual(property.bounds, constraintBounds)) {
       // Also plot CDF restricted to data that satisfies the constraint.
       const constraintStartBin = Math.floor(
         Math.max(
@@ -1093,15 +1074,15 @@ abstract class SegmentListGroupBase extends RefCounted {
 
   makeSegmentsVisible(visible: boolean) {
     const { visibleSegments } = this.group;
-    const segments = Array.from(this.listSegments(true));
+    const segments = Array.from(this.listSegments());
     visibleSegments.set(segments, visible);
   }
 
   invertVisibility() {
-    const markVisible: Uint64[] = [];
-    const markNonVisible: Uint64[] = [];
+    const markVisible: bigint[] = [];
+    const markNonVisible: bigint[] = [];
     const { visibleSegments } = this.group;
-    for (const segment of this.listSegments(true)) {
+    for (const segment of this.listSegments()) {
       if (visibleSegments.has(segment)) {
         markNonVisible.push(segment);
       } else {
@@ -1114,7 +1095,7 @@ abstract class SegmentListGroupBase extends RefCounted {
 
   selectSegments(select: boolean, changeVisibility = false) {
     const { selectedSegments, visibleSegments } = this.group;
-    const segments = Array.from(this.listSegments(true));
+    const segments = Array.from(this.listSegments());
     if (select || !changeVisibility) {
       selectedSegments.set(segments, select);
     }
@@ -1124,11 +1105,11 @@ abstract class SegmentListGroupBase extends RefCounted {
   }
 
   copySegments(onlyVisible = false) {
-    let ids = [...this.listSegments(true)];
+    let ids = [...this.listSegments()];
     if (onlyVisible) {
       ids = ids.filter((segment) => this.group.visibleSegments.has(segment));
     }
-    ids.sort(Uint64.compare);
+    ids.sort(bigintCompare);
     setClipboard(ids.join(", "));
   }
 
@@ -1148,7 +1129,7 @@ abstract class SegmentListGroupBase extends RefCounted {
           "neuroglancer-starred",
         );
         if (event.shiftKey) {
-          const nonVisibleSegments: Uint64[] = [];
+          const nonVisibleSegments: bigint[] = [];
           for (const segment of this.group.selectedSegments) {
             if (!this.group.visibleSegments.has(segment)) {
               nonVisibleSegments.push(segment);
@@ -1205,9 +1186,7 @@ abstract class SegmentListGroupBase extends RefCounted {
     this.registerDisposer(listSource.changed.add(this.debouncedUpdateStatus));
   }
 
-  *listSegments(safe = false): IterableIterator<Uint64> {
-    safe;
-  }
+  *listSegments(): IterableIterator<bigint> {}
 
   updateStatus() {
     const {
@@ -1300,8 +1279,7 @@ class SegmentListGroupSelected extends SegmentListGroupBase {
     super(listSource, group);
   }
 
-  listSegments(safe = false) {
-    safe;
+  listSegments() {
     return this.group.selectedSegments[Symbol.iterator](); // TODO, better way to call the iterator?
   }
 }
@@ -1314,14 +1292,13 @@ class SegmentListGroupQuery extends SegmentListGroupBase {
     listSource.debouncedUpdate.flush();
   }
 
-  listSegments(safe = false): IterableIterator<Uint64> {
+  listSegments(): IterableIterator<bigint> {
     const { listSource, segmentPropertyMap } = this;
     this.updateQuery();
     const queryResult = listSource.queryResult.value;
     return forEachQueryResultSegmentIdGenerator(
       segmentPropertyMap,
       queryResult,
-      safe,
     );
   }
 
diff --git a/src/ui/segment_split_merge_tools.ts b/src/ui/segment_split_merge_tools.ts
index 4b3211b515..3a04792bf9 100644
--- a/src/ui/segment_split_merge_tools.ts
+++ b/src/ui/segment_split_merge_tools.ts
@@ -40,7 +40,6 @@ import {
 import { animationFrameDebounce } from "#src/util/animation_frame_debounce.js";
 import { removeChildren } from "#src/util/dom.js";
 import { EventActionMap } from "#src/util/keyboard_bindings.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 export const ANNOTATE_MERGE_SEGMENTS_TOOL_ID = "mergeSegments";
 export const ANNOTATE_SPLIT_SEGMENTS_TOOL_ID = "splitSegments";
@@ -57,7 +56,7 @@ const SPLIT_SEGMENTS_INPUT_EVENT_MAP = EventActionMap.fromObject({
 });
 
 export class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
-  lastAnchorBaseSegment = new WatchableValue<Uint64 | undefined>(undefined);
+  lastAnchorBaseSegment = new WatchableValue<bigint | undefined>(undefined);
 
   constructor(layer: SegmentationUserLayer) {
     super(layer);
@@ -71,13 +70,9 @@ export class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
       const { segmentEquivalences } =
         layer.displayState.segmentationGroupState.value;
       const mappedAnchorSegment = segmentEquivalences.get(anchorSegment);
-      if (
-        !Uint64.equal(
-          segmentSelectionState.selectedSegment,
-          mappedAnchorSegment,
-        )
-      )
+      if (segmentSelectionState.selectedSegment !== mappedAnchorSegment) {
         return;
+      }
       const base = segmentSelectionState.baseSelectedSegment;
       const isBase = isBaseSegmentId(base);
       // TODO: This would ideally rely on a separate HIGH_BIT_REPRESENTATIVE flag,
@@ -94,7 +89,7 @@ export class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
       ) {
         return;
       }
-      this.lastAnchorBaseSegment.value = base.clone();
+      this.lastAnchorBaseSegment.value = base;
     };
     this.registerDisposer(
       layer.displayState.segmentSelectionState.changed.add(
@@ -115,7 +110,7 @@ export class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
       this.layer.displayState.segmentationGroupState.value;
 
     const getAnchorSegment = (): {
-      anchorSegment: Uint64 | undefined;
+      anchorSegment: bigint | undefined;
       error: string | undefined;
     } => {
       const anchorSegment = this.layer.anchorSegment.value;
@@ -136,10 +131,8 @@ export class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
       }
       if (
         baseAnchorSegment === undefined ||
-        !Uint64.equal(
-          segmentationGroupState.segmentEquivalences.get(baseAnchorSegment),
-          anchorGraphSegment,
-        )
+        segmentationGroupState.segmentEquivalences.get(baseAnchorSegment) !==
+          anchorGraphSegment
       ) {
         return {
           anchorSegment,
@@ -151,8 +144,8 @@ export class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
     };
 
     const getMergeRequest = (): {
-      anchorSegment: Uint64 | undefined;
-      otherSegment: Uint64 | undefined;
+      anchorSegment: bigint | undefined;
+      otherSegment: bigint | undefined;
       anchorSegmentValid: boolean;
       error: string | undefined;
     } => {
@@ -169,10 +162,8 @@ export class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
       const otherSegment = displayState.segmentSelectionState.baseValue;
       if (
         otherSegment === undefined ||
-        Uint64.equal(
-          displayState.segmentSelectionState.selectedSegment,
-          segmentationGroupState.segmentEquivalences.get(anchorSegment),
-        )
+        displayState.segmentSelectionState.selectedSegment ===
+          segmentationGroupState.segmentEquivalences.get(anchorSegment)
       ) {
         return {
           anchorSegment,
@@ -287,11 +278,8 @@ export class MergeSegmentsTool extends LayerTool<SegmentationUserLayer> {
       if (other === undefined) return;
       const existingAnchor = this.layer.anchorSegment.value;
       segmentationGroupState.visibleSegments.add(other);
-      if (
-        existingAnchor === undefined ||
-        !Uint64.equal(existingAnchor, other)
-      ) {
-        this.layer.anchorSegment.value = other.clone();
+      if (existingAnchor === undefined || existingAnchor !== other) {
+        this.layer.anchorSegment.value = other;
         return;
       }
     });
@@ -313,7 +301,7 @@ export class SplitSegmentsTool extends LayerTool<SegmentationUserLayer> {
       this.layer.displayState.segmentationGroupState.value;
 
     const getAnchorSegment = (): {
-      anchorSegment: Uint64 | undefined;
+      anchorSegment: bigint | undefined;
       error: string | undefined;
     } => {
       const anchorSegment = this.layer.anchorSegment.value;
@@ -340,8 +328,8 @@ export class SplitSegmentsTool extends LayerTool<SegmentationUserLayer> {
     body.classList.add("neuroglancer-merge-segments-status");
     activation.bindInputEventMap(SPLIT_SEGMENTS_INPUT_EVENT_MAP);
     const getSplitRequest = (): {
-      anchorSegment: Uint64 | undefined;
-      otherSegment: Uint64 | undefined;
+      anchorSegment: bigint | undefined;
+      otherSegment: bigint | undefined;
       anchorSegmentValid: boolean;
       error: string | undefined;
     } => {
@@ -358,11 +346,9 @@ export class SplitSegmentsTool extends LayerTool<SegmentationUserLayer> {
       const otherSegment = displayState.segmentSelectionState.baseValue;
       if (
         otherSegment === undefined ||
-        !Uint64.equal(
-          displayState.segmentSelectionState.selectedSegment,
-          segmentationGroupState.segmentEquivalences.get(anchorSegment),
-        ) ||
-        Uint64.equal(otherSegment, anchorSegment)
+        displayState.segmentSelectionState.selectedSegment !==
+          segmentationGroupState.segmentEquivalences.get(anchorSegment) ||
+        otherSegment === anchorSegment
       ) {
         return {
           anchorSegment,
@@ -521,11 +507,8 @@ export class SplitSegmentsTool extends LayerTool<SegmentationUserLayer> {
       if (other === undefined) return;
       segmentationGroupState.visibleSegments.add(other);
       const existingAnchor = this.layer.anchorSegment.value;
-      if (
-        existingAnchor === undefined ||
-        !Uint64.equal(existingAnchor, other)
-      ) {
-        this.layer.anchorSegment.value = other.clone();
+      if (existingAnchor === undefined || existingAnchor !== other) {
+        this.layer.anchorSegment.value = other;
         return;
       }
     });
diff --git a/src/ui/url_hash_binding.ts b/src/ui/url_hash_binding.ts
index 978942494c..29438cd483 100644
--- a/src/ui/url_hash_binding.ts
+++ b/src/ui/url_hash_binding.ts
@@ -19,7 +19,11 @@ import type { SharedKvStoreContext } from "#src/kvstore/frontend.js";
 import { StatusMessage } from "#src/status.js";
 import { WatchableValue } from "#src/trackable_value.js";
 import { RefCounted } from "#src/util/disposable.js";
-import { urlSafeParse, verifyObject } from "#src/util/json.js";
+import {
+  bigintToStringJsonReplacer,
+  urlSafeParse,
+  verifyObject,
+} from "#src/util/json.js";
 import type { Trackable } from "#src/util/trackable.js";
 import { getCachedJson } from "#src/util/trackable.js";
 
@@ -92,7 +96,9 @@ export class UrlHashBinding extends RefCounted {
     const { generation } = cacheState;
     if (generation !== this.prevStateGeneration) {
       this.prevStateGeneration = cacheState.generation;
-      const stateString = encodeFragment(JSON.stringify(cacheState.value));
+      const stateString = encodeFragment(
+        JSON.stringify(cacheState.value, bigintToStringJsonReplacer),
+      );
       if (stateString !== this.prevStateString) {
         this.prevStateString = stateString;
         if (decodeURIComponent(stateString) === "{}") {
diff --git a/src/uint64_map.spec.ts b/src/uint64_map.spec.ts
index c908755eb0..9d0336bf48 100644
--- a/src/uint64_map.spec.ts
+++ b/src/uint64_map.spec.ts
@@ -20,41 +20,36 @@
 
 import { describe, it, expect } from "vitest";
 import { Uint64Map } from "#src/uint64_map.js";
-import { Uint64 } from "#src/util/uint64.js";
+import { bigintCompare, uint64FromLowHigh } from "#src/util/bigint.js";
 
 describe("Uint64Map", () => {
   it("basic", () => {
     const m = new Uint64Map();
 
-    const k1 = new Uint64(1);
-    const v1 = new Uint64(11);
+    const k1 = 1n;
+    const v1 = 11n;
     expect(m.has(k1)).toBe(false);
     expect(m.size).toBe(0);
     m.set(k1, v1);
     expect(m.has(k1)).toBe(true);
     expect(m.size).toBe(1);
-    const k1Gotten = new Uint64();
-    m.get(k1, k1Gotten);
-    expect(k1Gotten).toEqual(v1);
+    expect(m.get(k1)).toEqual(v1);
 
-    const k2 = new Uint64(2, 3);
-    const v2 = new Uint64(22, 33);
+    const k2 = uint64FromLowHigh(2, 3);
+    const v2 = uint64FromLowHigh(22, 33);
     expect(m.has(k2)).toBe(false);
     m.set(k2, v2);
     expect(m.has(k1)).toBe(true);
     expect(m.has(k2)).toBe(true);
     expect(m.size).toBe(2);
-    const k2Gotten = new Uint64();
-    m.get(k2, k2Gotten);
-    expect(k2Gotten).toEqual(v2);
+    expect(m.get(k2)).toEqual(v2);
 
-    const v2a = new Uint64(222, 333);
+    const v2a = uint64FromLowHigh(222, 333);
     m.set(k2, v2a);
     expect(m.has(k1)).toBe(true);
     expect(m.has(k2)).toBe(true);
     expect(m.size).toBe(2);
-    m.get(k2, k2Gotten);
-    expect(k2Gotten).toEqual(v2);
+    expect(m.get(k2)).toEqual(v2);
 
     m.delete(k2);
     expect(m.has(k1)).toBe(true);
@@ -64,8 +59,7 @@ describe("Uint64Map", () => {
     expect(m.has(k1)).toBe(true);
     expect(m.has(k2)).toBe(true);
     expect(m.size).toBe(2);
-    m.get(k2, k2Gotten);
-    expect(k2Gotten).toEqual(v2a);
+    expect(m.get(k2)).toEqual(v2a);
 
     m.clear();
     expect(m.has(k1)).toBe(false);
@@ -76,21 +70,21 @@ describe("Uint64Map", () => {
   it("iterate", () => {
     const m = new Uint64Map();
 
-    const k1 = new Uint64(1);
-    const v1 = new Uint64(11);
-    const k2 = new Uint64(2, 3);
-    const v2 = new Uint64(22, 33);
-    const k3 = new Uint64(3, 4);
-    const v3 = new Uint64(33, 44);
+    const k1 = 1n;
+    const v1 = 11n;
+    const k2 = uint64FromLowHigh(2, 3);
+    const v2 = uint64FromLowHigh(22, 33);
+    const k3 = uint64FromLowHigh(3, 4);
+    const v3 = uint64FromLowHigh(33, 44);
     m.set(k2, v2);
     m.set(k1, v1);
     m.set(k3, v3);
 
     const iterated = [];
-    for (const [k, v] of m.unsafeEntries()) {
-      iterated.push([k.clone(), v.clone()]);
+    for (const [k, v] of m) {
+      iterated.push([k, v]);
     }
-    iterated.sort((a, b) => Uint64.compare(a[0], b[0]));
+    iterated.sort((a, b) => bigintCompare(a[0], b[0]));
     expect(iterated).toEqual([
       [k1, v1],
       [k2, v2],
@@ -101,12 +95,12 @@ describe("Uint64Map", () => {
   it("toJSON", () => {
     const m = new Uint64Map();
 
-    const k1 = new Uint64(1);
-    const v1 = new Uint64(11);
-    const k2 = new Uint64(2, 3);
-    const v2 = new Uint64(22, 33);
-    const k3 = new Uint64(3, 4);
-    const v3 = new Uint64(33, 44);
+    const k1 = 1n;
+    const v1 = 11n;
+    const k2 = uint64FromLowHigh(2, 3);
+    const v2 = uint64FromLowHigh(22, 33);
+    const k3 = uint64FromLowHigh(3, 4);
+    const v3 = uint64FromLowHigh(33, 44);
     m.set(k2, v2);
     m.set(k1, v1);
     m.set(k3, v3);
diff --git a/src/uint64_map.ts b/src/uint64_map.ts
index 22f94d58ef..b767ba6f0d 100644
--- a/src/uint64_map.ts
+++ b/src/uint64_map.ts
@@ -21,7 +21,6 @@
 import { HashMapUint64 } from "#src/gpu_hash/hash_table.js";
 import type { WatchableValueInterface } from "#src/trackable_value.js";
 import { Signal } from "#src/util/signal.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import type { RPC } from "#src/worker_rpc.js";
 import {
   registerRPC,
@@ -35,7 +34,7 @@ export class Uint64Map
   implements WatchableValueInterface<Uint64Map>
 {
   hashTable = new HashMapUint64();
-  changed = new Signal<(x: Uint64 | null, add: boolean) => void>();
+  changed = new Signal<(x: bigint | null, add: boolean) => void>();
 
   get value() {
     return this;
@@ -47,11 +46,11 @@ export class Uint64Map
     return obj;
   }
 
-  set_(key: Uint64, value: Uint64) {
+  set_(key: bigint, value: bigint) {
     return this.hashTable.set(key, value);
   }
 
-  set(key: Uint64, value: Uint64) {
+  set(key: bigint, value: bigint) {
     if (this.set_(key, value)) {
       const { rpc } = this;
       if (rpc) {
@@ -61,27 +60,23 @@ export class Uint64Map
     }
   }
 
-  has(key: Uint64) {
+  has(key: bigint) {
     return this.hashTable.has(key);
   }
 
-  get(key: Uint64, value: Uint64): boolean {
-    return this.hashTable.get(key, value);
+  get(key: bigint): bigint | undefined {
+    return this.hashTable.get(key);
   }
 
   [Symbol.iterator]() {
     return this.hashTable.entries();
   }
 
-  unsafeEntries() {
-    return this.hashTable.unsafeEntries();
-  }
-
-  delete_(key: Uint64) {
+  delete_(key: bigint) {
     return this.hashTable.delete(key);
   }
 
-  delete(key: Uint64) {
+  delete(key: bigint) {
     if (this.delete_(key)) {
       const { rpc } = this;
       if (rpc) {
@@ -97,7 +92,7 @@ export class Uint64Map
 
   assignFrom(other: Uint64Map) {
     this.clear();
-    for (const [key, value] of other.unsafeEntries()) {
+    for (const [key, value] of other) {
       this.set(key, value);
     }
   }
@@ -114,7 +109,7 @@ export class Uint64Map
 
   toJSON() {
     const result: { [key: string]: string } = {};
-    for (const [key, value] of this.hashTable.unsafeEntries()) {
+    for (const [key, value] of this.hashTable.entries()) {
       result[key.toString()] = value.toString();
     }
     return result;
diff --git a/src/uint64_ordered_set.ts b/src/uint64_ordered_set.ts
index 5986d250ee..bd607e2a26 100644
--- a/src/uint64_ordered_set.ts
+++ b/src/uint64_ordered_set.ts
@@ -16,13 +16,12 @@
 
 import type { WatchableValueInterface } from "#src/trackable_value.js";
 import { Signal } from "#src/util/signal.js";
-import type { Uint64 } from "#src/util/uint64.js";
 
 export class Uint64OrderedSet
   implements WatchableValueInterface<Uint64OrderedSet>
 {
-  changed = new Signal<(x: Uint64 | Uint64[] | null, add: boolean) => void>();
-  private data = new Map<bigint, Uint64>();
+  changed = new Signal<(x: bigint | bigint[] | null, add: boolean) => void>();
+  private data = new Set<bigint>();
 
   dispose() {
     this.data.clear();
@@ -36,30 +35,27 @@ export class Uint64OrderedSet
     return this;
   }
 
-  has(x: Uint64) {
-    return this.data.has(BigInt(x.toString()));
+  has(x: bigint) {
+    return this.data.has(x);
   }
 
-  add(x: Uint64 | Uint64[]) {
+  add(x: bigint | bigint[] | BigUint64Array) {
     const { data } = this;
-    if (Array.isArray(x)) {
-      const added: Uint64[] = [];
-      for (let num of x) {
-        const bignum = BigInt(num.toString());
-        if (data.has(bignum)) continue;
-        num = num.clone();
+    if (typeof x !== "bigint") {
+      const added: bigint[] = [];
+      for (const num of x) {
+        if (data.has(num)) continue;
         added.push(num);
-        data.set(bignum, num);
+        data.add(num);
       }
       if (added.length !== 0) {
         this.changed.dispatch(added, true);
       }
     } else {
-      const bignum = BigInt(x.toString());
-      if (data.has(bignum)) {
+      if (data.has(x)) {
         return;
       }
-      data.set(bignum, x.clone());
+      data.add(x);
       this.changed.dispatch(x, true);
     }
   }
@@ -68,30 +64,28 @@ export class Uint64OrderedSet
     return this.data.values();
   }
 
-  delete(x: Uint64 | Uint64[]) {
+  delete(x: bigint | bigint[] | BigUint64Array) {
     const { data } = this;
-    if (Array.isArray(x)) {
-      const removed: Uint64[] = [];
+    if (typeof x !== "bigint") {
+      const removed: bigint[] = [];
       for (const num of x) {
-        const bignum = BigInt(num.toString());
-        if (!data.has(bignum)) continue;
-        data.delete(bignum);
+        if (!data.has(num)) continue;
+        data.delete(num);
         removed.push(num);
       }
       if (removed.length !== 0) {
         this.changed.dispatch(removed, false);
       }
     } else {
-      const bignum = BigInt(x.toString());
-      if (!data.has(bignum)) {
+      if (!data.has(x)) {
         return;
       }
-      data.delete(bignum);
+      data.delete(x);
       this.changed.dispatch(x, false);
     }
   }
 
-  set(x: Uint64 | Uint64[], value: boolean) {
+  set(x: bigint | bigint[] | BigUint64Array, value: boolean) {
     if (!value) {
       this.delete(x);
     } else {
@@ -107,16 +101,16 @@ export class Uint64OrderedSet
   }
 
   toJSON() {
-    return Array.from(this.data.keys(), (x) => x.toString());
+    return Array.from(this.data, (x) => x.toString());
   }
 
   assignFrom(other: Uint64OrderedSet) {
     this.clear();
     const otherData = other.data;
     const { data } = this;
-    const added = Array.from(otherData.values());
-    for (const [key, value] of otherData) {
-      data.set(key, value);
+    const added = Array.from(otherData);
+    for (const x of otherData) {
+      data.add(x);
     }
     this.changed.dispatch(added, true);
   }
diff --git a/src/uint64_set.spec.ts b/src/uint64_set.spec.ts
index bf03098e94..9d4e58abc5 100644
--- a/src/uint64_set.spec.ts
+++ b/src/uint64_set.spec.ts
@@ -20,27 +20,27 @@
 
 import { describe, it, expect } from "vitest";
 import { Uint64Set } from "#src/uint64_set.js";
-import { Uint64 } from "#src/util/uint64.js";
+import { uint64FromLowHigh } from "#src/util/bigint.js";
 
 describe("Uint64Set", () => {
   it("basic", () => {
     const s = new Uint64Set();
 
-    const v1 = new Uint64(1);
+    const v1 = 1n;
     expect(s.has(v1)).toBe(false);
     expect(s.size).toBe(0);
     s.add(v1);
     expect(s.has(v1)).toBe(true);
     expect(s.size).toBe(1);
 
-    const v2 = new Uint64(2, 3);
+    const v2 = uint64FromLowHigh(2, 3);
     expect(s.has(v2)).toBe(false);
     s.add(v2);
     expect(s.has(v1)).toBe(true);
     expect(s.has(v2)).toBe(true);
     expect(s.size).toBe(2);
 
-    const v1a = new Uint64(1);
+    const v1a = 1n;
     s.add(v1a);
     expect(s.has(v1)).toBe(true);
     expect(s.has(v2)).toBe(true);
@@ -52,7 +52,7 @@ describe("Uint64Set", () => {
     expect(s.has(v2)).toBe(true);
     expect(s.size).toBe(1);
 
-    const v3 = new Uint64(3, 4);
+    const v3 = uint64FromLowHigh(3, 4);
     expect(s.has(v3)).toBe(false);
     s.add(v3);
     expect(s.has(v1)).toBe(false);
@@ -70,16 +70,16 @@ describe("Uint64Set", () => {
   it("iterate", () => {
     const s = new Uint64Set();
 
-    const v1 = new Uint64(1);
-    const v2 = new Uint64(2, 3);
-    const v3 = new Uint64(3, 4);
+    const v1 = 1n;
+    const v2 = uint64FromLowHigh(2, 3);
+    const v3 = uint64FromLowHigh(3, 4);
     s.add(v2);
     s.add(v1);
     s.add(v3);
 
     const iterated = [];
-    for (const v of s.unsafeKeys()) {
-      iterated.push(v.clone());
+    for (const v of s.keys()) {
+      iterated.push(v);
     }
     iterated.sort();
     expect(iterated).toEqual([v1, v2, v3]);
@@ -88,9 +88,9 @@ describe("Uint64Set", () => {
   it("toJSON", () => {
     const s = new Uint64Set();
 
-    const v1 = new Uint64(1);
-    const v2 = new Uint64(2, 3);
-    const v3 = new Uint64(3, 4);
+    const v1 = 1n;
+    const v2 = uint64FromLowHigh(2, 3);
+    const v3 = uint64FromLowHigh(3, 4);
     s.add(v2);
     s.add(v1);
     s.add(v3);
diff --git a/src/uint64_set.ts b/src/uint64_set.ts
index 671106d287..1683e99905 100644
--- a/src/uint64_set.ts
+++ b/src/uint64_set.ts
@@ -17,7 +17,6 @@
 import { HashSetUint64 } from "#src/gpu_hash/hash_table.js";
 import type { WatchableValueInterface } from "#src/trackable_value.js";
 import { Signal } from "#src/util/signal.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import type { RPC } from "#src/worker_rpc.js";
 import {
   registerRPC,
@@ -31,7 +30,9 @@ export class Uint64Set
   implements WatchableValueInterface<Uint64Set>
 {
   hashTable = new HashSetUint64();
-  changed = new Signal<(x: Uint64 | Uint64[] | null, add: boolean) => void>();
+  changed = new Signal<
+    (x: bigint | bigint[] | BigUint64Array | null, add: boolean) => void
+  >();
 
   get value() {
     return this;
@@ -43,7 +44,7 @@ export class Uint64Set
     return obj;
   }
 
-  set(x: Uint64 | Uint64[], value: boolean) {
+  set(x: bigint | bigint[] | BigUint64Array, value: boolean) {
     if (!value) {
       this.delete(x);
     } else {
@@ -64,7 +65,7 @@ export class Uint64Set
     }
   }
 
-  add_(x: Uint64[]) {
+  add_(x: bigint[] | BigUint64Array) {
     let changed = false;
     for (const v of x) {
       changed = this.hashTable.add(v) || changed;
@@ -72,8 +73,8 @@ export class Uint64Set
     return changed;
   }
 
-  add(x: Uint64 | Uint64[]) {
-    const tmp = Array<Uint64>().concat(x);
+  add(x: bigint | bigint[] | BigUint64Array) {
+    const tmp = typeof x === "bigint" ? [x] : x;
     if (this.add_(tmp)) {
       const { rpc } = this;
       if (rpc) {
@@ -83,7 +84,7 @@ export class Uint64Set
     }
   }
 
-  has(x: Uint64) {
+  has(x: bigint) {
     return this.hashTable.has(x);
   }
 
@@ -91,11 +92,11 @@ export class Uint64Set
     return this.hashTable.keys();
   }
 
-  unsafeKeys() {
-    return this.hashTable.unsafeKeys();
+  keys() {
+    return this.hashTable.keys();
   }
 
-  delete_(x: Uint64[]) {
+  delete_(x: bigint[] | BigUint64Array) {
     let changed = false;
     for (const v of x) {
       changed = this.hashTable.delete(v) || changed;
@@ -103,9 +104,9 @@ export class Uint64Set
     return changed;
   }
 
-  delete(x: Uint64 | Uint64[]) {
-    const tmp = Array<Uint64>().concat(x);
-    if (this.delete_(Array<Uint64>().concat(x))) {
+  delete(x: bigint | bigint[] | BigUint64Array) {
+    const tmp = typeof x === "bigint" ? [x] : x;
+    if (this.delete_(tmp)) {
       const { rpc } = this;
       if (rpc) {
         rpc.invoke("Uint64Set.delete", { id: this.rpcId, value: tmp });
@@ -130,7 +131,7 @@ export class Uint64Set
 
   toJSON() {
     const result = new Array<string>();
-    for (const id of this.unsafeKeys()) {
+    for (const id of this.keys()) {
       result.push(id.toString());
     }
     // Need to sort entries, otherwise serialization changes every time.
@@ -140,7 +141,7 @@ export class Uint64Set
 
   assignFrom(other: Uint64Set) {
     this.clear();
-    for (const key of other.unsafeKeys()) {
+    for (const key of other.keys()) {
       this.add(key);
     }
   }
diff --git a/src/util/bigint.ts b/src/util/bigint.ts
new file mode 100644
index 0000000000..7fe63933ab
--- /dev/null
+++ b/src/util/bigint.ts
@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google Inc.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export function bigintCompare(a: bigint, b: bigint) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+export function uint64FromLowHigh(low: number, high: number) {
+  return BigInt(low) | (BigInt(high) << 32n);
+}
+
+export function randomUint64(): bigint {
+  const low = (Math.random() * 0x100000000) >>> 0;
+  const high = (Math.random() * 0x100000000) >>> 0;
+  return uint64FromLowHigh(low, high);
+}
+
+export function wrapSigned32BitIntegerToUint64(value: number): bigint {
+  return uint64FromLowHigh(value >>> 0, value < 0 ? 0xffffffff : 0);
+}
+
+export function bigintMin(a: bigint, b: bigint): bigint {
+  return a < b ? a : b;
+}
+
+export function bigintMax(a: bigint, b: bigint): bigint {
+  return a > b ? a : b;
+}
+
+export const UINT64_MAX = 0xffffffffffffffffn;
+
+export function clampToUint64(x: bigint): bigint {
+  if (x < 0n) return 0n;
+  if (x > UINT64_MAX) return UINT64_MAX;
+  return x;
+}
+
+export function bigintAbs(x: bigint): bigint {
+  return x < 0n ? -x : x;
+}
+
+export function roundToUint64(x: number | bigint): bigint {
+  if (typeof x === "number") {
+    if (x === Number.POSITIVE_INFINITY) return UINT64_MAX;
+    if (!Number.isFinite(x)) return 0n;
+    x = BigInt(Math.round(x));
+  }
+  return clampToUint64(x);
+}
diff --git a/src/util/data_type.ts b/src/util/data_type.ts
index 199d7c937a..4102f661ae 100644
--- a/src/util/data_type.ts
+++ b/src/util/data_type.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { TypedNumberArrayConstructor } from "#src/util/array.js";
+import type { TypedArrayConstructor } from "#src/util/array.js";
 
 /**
  * If this is updated, DATA_TYPE_BYTES must also be updated.
@@ -54,7 +54,7 @@ export const DATA_TYPE_BYTES: Record<DataType, number> = {
 
 export const DATA_TYPE_ARRAY_CONSTRUCTOR: Record<
   DataType,
-  TypedNumberArrayConstructor
+  TypedArrayConstructor
 > = {
   [DataType.UINT8]: Uint8Array,
   [DataType.INT8]: Int8Array,
@@ -62,24 +62,10 @@ export const DATA_TYPE_ARRAY_CONSTRUCTOR: Record<
   [DataType.INT16]: Int16Array,
   [DataType.UINT32]: Uint32Array,
   [DataType.INT32]: Int32Array,
-  [DataType.UINT64]: Uint32Array,
+  [DataType.UINT64]: BigUint64Array,
   [DataType.FLOAT32]: Float32Array,
 };
 
-export const DATA_TYPE_JAVASCRIPT_ELEMENTS_PER_ARRAY_ELEMENT: Record<
-  DataType,
-  number
-> = {
-  [DataType.UINT8]: 1,
-  [DataType.INT8]: 1,
-  [DataType.UINT16]: 1,
-  [DataType.INT16]: 1,
-  [DataType.UINT32]: 1,
-  [DataType.INT32]: 1,
-  [DataType.UINT64]: 2,
-  [DataType.FLOAT32]: 1,
-};
-
 export function makeDataTypeArrayView<TArrayBuffer extends ArrayBufferLike>(
   dataType: DataType,
   buffer: TArrayBuffer,
@@ -87,13 +73,11 @@ export function makeDataTypeArrayView<TArrayBuffer extends ArrayBufferLike>(
   byteLength: number = buffer.byteLength,
 ): ArrayBufferView<TArrayBuffer> {
   const bytesPerElement = DATA_TYPE_BYTES[dataType];
-  const javascriptElementsPerArrayElement =
-    DATA_TYPE_JAVASCRIPT_ELEMENTS_PER_ARRAY_ELEMENT[dataType];
   return new (DATA_TYPE_ARRAY_CONSTRUCTOR[
     dataType
-  ] as TypedNumberArrayConstructor<TArrayBuffer>)(
+  ] as TypedArrayConstructor<TArrayBuffer>)(
     buffer,
     byteOffset,
-    (byteLength / bytesPerElement) * javascriptElementsPerArrayElement,
+    byteLength / bytesPerElement,
   );
 }
diff --git a/src/util/disjoint_sets.spec.ts b/src/util/disjoint_sets.spec.ts
index 61ef1519df..8669080eea 100644
--- a/src/util/disjoint_sets.spec.ts
+++ b/src/util/disjoint_sets.spec.ts
@@ -15,19 +15,19 @@
  */
 
 import { describe, it, expect } from "vitest";
+import { bigintCompare } from "#src/util/bigint.js";
 import { DisjointUint64Sets } from "#src/util/disjoint_sets.js";
-import { Uint64 } from "#src/util/uint64.js";
 
-function getSortedElementStrings(disjointSets: DisjointUint64Sets, x: Uint64) {
+function getSortedElements(disjointSets: DisjointUint64Sets, x: bigint) {
   const members = Array.from(disjointSets.setElements(x));
-  members.sort(Uint64.compare);
-  return members.map((v) => v.toString());
+  members.sort(bigintCompare);
+  return members;
 }
 
-function getContiguousElementStrings(start: number, end: number) {
-  const result = new Array<string>(end - start);
-  for (let i = 0, length = result.length; i < length; ++i) {
-    result[i] = (start + i).toString();
+function getContiguousElements(start: bigint, end: bigint) {
+  const result = new Array<bigint>();
+  for (let i = start; i < end; ++i) {
+    result.push(i);
   }
   return result;
 }
@@ -36,67 +36,66 @@ describe("disjoint_sets", () => {
   it("basic", () => {
     const disjointSets = new DisjointUint64Sets();
     // Link the first 25 elements.
-    for (let i = 0; i < 24; ++i) {
-      const a = new Uint64(i, 0);
-      const b = new Uint64(i + 1, 0);
-      expect(disjointSets.get(a).toString()).toEqual("0");
+    for (let i = 0n; i < 24n; ++i) {
+      const a = i;
+      const b = i + 1n;
+      expect(disjointSets.get(a)).toEqual(0n);
       expect(disjointSets.get(b)).toBe(b);
       disjointSets.link(a, b);
-      expect(disjointSets.get(a).toString()).toEqual("0");
-      expect(disjointSets.get(b).toString()).toEqual("0");
-      expect(getSortedElementStrings(disjointSets, a)).toEqual(
-        getContiguousElementStrings(0, i + 2),
+      expect(disjointSets.get(a)).toEqual(0n);
+      expect(disjointSets.get(b)).toEqual(0n);
+      expect(getSortedElements(disjointSets, a)).toEqual(
+        getContiguousElements(0n, i + 2n),
       );
     }
 
     // Link the next 25 elements.
-    for (let i = 25; i < 49; ++i) {
-      const a = new Uint64(i, 0);
-      const b = new Uint64(i + 1, 0);
-      expect(disjointSets.get(a).toString()).toEqual("25");
+    for (let i = 25n; i < 49n; ++i) {
+      const a = i;
+      const b = i + 1n;
+      expect(disjointSets.get(a)).toEqual(25n);
       expect(disjointSets.get(b)).toBe(b);
       disjointSets.link(a, b);
-      expect(disjointSets.get(a).toString()).toEqual("25");
-      expect(disjointSets.get(b).toString()).toEqual("25");
-      expect(getSortedElementStrings(disjointSets, a)).toEqual(
-        getContiguousElementStrings(25, i + 2),
+      expect(disjointSets.get(a)).toEqual(25n);
+      expect(disjointSets.get(b)).toEqual(25n);
+      expect(getSortedElements(disjointSets, a)).toEqual(
+        getContiguousElements(25n, i + 2n),
       );
     }
 
     // Link the two sets of 25 elements each.
-    expect(disjointSets.link(new Uint64(15, 0), new Uint64(40, 0))).toBe(true);
-    expect(disjointSets.get(new Uint64(15, 0)).toString()).toEqual("0");
-    expect(disjointSets.get(new Uint64(40, 0)).toString()).toEqual("0");
-    expect(getSortedElementStrings(disjointSets, new Uint64(15, 0))).toEqual(
-      getContiguousElementStrings(0, 50),
+    expect(disjointSets.link(15n, 40n)).toBe(true);
+    expect(disjointSets.get(15n)).toEqual(0n);
+    expect(disjointSets.get(40n)).toEqual(0n);
+    expect(getSortedElements(disjointSets, 15n)).toEqual(
+      getContiguousElements(0n, 50n),
     );
 
     // Does nothing, the two elements are already merged.
-    expect(disjointSets.link(new Uint64(15, 0), new Uint64(40, 0))).toBe(false);
+    expect(disjointSets.link(15n, 40n)).toBe(false);
 
-    for (let i = 0; i < 50; ++i) {
-      const x = new Uint64(i, 0);
+    for (let x = 0n; x < 50n; ++x) {
       // Check that the same representative is returned.
-      expect(disjointSets.get(x).toString()).toEqual("0");
-      // Check that getSortedElementStrings returns the same list for each member of a set.
-      expect(getSortedElementStrings(disjointSets, x)).toEqual(
-        getContiguousElementStrings(0, 50),
+      expect(disjointSets.get(x)).toEqual(0n);
+      // Check that getSortedElements returns the same list for each member of a set.
+      expect(getSortedElements(disjointSets, x)).toEqual(
+        getContiguousElements(0n, 50n),
       );
     }
 
     // Check that non-linked elements correctly have only a single element.
-    for (let i = 51; i < 100; ++i) {
-      expect(getSortedElementStrings(disjointSets, new Uint64(i, 0))).toEqual(
-        getContiguousElementStrings(i, i + 1),
+    for (let i = 51n; i < 100n; ++i) {
+      expect(getSortedElements(disjointSets, i)).toEqual(
+        getContiguousElements(i, i + 1n),
       );
     }
   });
 
   it("toJSON", () => {
     const disjointSets = new DisjointUint64Sets();
-    disjointSets.link(Uint64.parseString("5"), Uint64.parseString("0"));
-    disjointSets.link(Uint64.parseString("2"), Uint64.parseString("10"));
-    disjointSets.link(Uint64.parseString("2"), Uint64.parseString("3"));
+    disjointSets.link(5n, 0n);
+    disjointSets.link(2n, 10n);
+    disjointSets.link(2n, 3n);
     expect(JSON.stringify(disjointSets)).toEqual('[["0","5"],["2","3","10"]]');
   });
 });
diff --git a/src/util/disjoint_sets.ts b/src/util/disjoint_sets.ts
index 94e8c1e873..cca10262c5 100644
--- a/src/util/disjoint_sets.ts
+++ b/src/util/disjoint_sets.ts
@@ -17,152 +17,144 @@
 import { VisibleSegmentEquivalencePolicy } from "#src/segmentation_graph/segment_id.js";
 import type { WatchableValueInterface } from "#src/trackable_value.js";
 import { WatchableValue } from "#src/trackable_value.js";
-import { Uint64 } from "#src/util/uint64.js";
+import { bigintCompare } from "#src/util/bigint.js";
 
-const rankSymbol = Symbol("disjoint_sets:rank");
-const parentSymbol = Symbol("disjoint_sets:parent");
-const nextSymbol = Symbol("disjoint_sets:next");
-const prevSymbol = Symbol("disjoint_sets:prev");
+class Entry {
+  rank: number = 0;
+  parent: Entry = this;
+  next: Entry = this;
+  prev: Entry = this;
+  min: bigint;
 
-function findRepresentative(v: any): any {
+  constructor(public value: bigint) {
+    this.min = value;
+  }
+}
+
+function findRepresentative(v: Entry): Entry {
   // First pass: find the root, which will be stored in ancestor.
   let old = v;
-  let ancestor = v[parentSymbol];
+  let ancestor = v.parent;
   while (ancestor !== v) {
     v = ancestor;
-    ancestor = v[parentSymbol];
+    ancestor = v.parent;
   }
   // Second pass: set all of the parent pointers along the path from the
   // original element `old' to refer directly to the root `ancestor'.
-  v = old[parentSymbol];
+  v = old.parent;
   while (ancestor !== v) {
-    old[parentSymbol] = ancestor;
+    old.parent = ancestor;
     old = v;
-    v = old[parentSymbol];
+    v = old.parent;
   }
   return ancestor;
 }
 
-function linkUnequalSetRepresentatives(i: any, j: any): any {
-  const iRank = i[rankSymbol];
-  const jRank = j[rankSymbol];
+function linkUnequalSetRepresentatives(i: Entry, j: Entry): Entry {
+  const iRank = i.rank;
+  const jRank = j.rank;
   if (iRank > jRank) {
-    j[parentSymbol] = i;
+    j.parent = i;
     return i;
   }
 
-  i[parentSymbol] = j;
+  i.parent = j;
   if (iRank === jRank) {
-    j[rankSymbol] = jRank + 1;
+    j.rank = jRank + 1;
   }
   return j;
 }
 
-function spliceCircularLists(i: any, j: any) {
-  const iPrev = i[prevSymbol];
-  const jPrev = j[prevSymbol];
+function spliceCircularLists(i: Entry, j: Entry) {
+  const iPrev = i.prev;
+  const jPrev = j.prev;
 
   // Connect end of i to beginning of j.
-  j[prevSymbol] = iPrev;
-  iPrev[nextSymbol] = j;
+  j.prev = iPrev;
+  iPrev.next = j;
 
   // Connect end of j to beginning of i.
-  i[prevSymbol] = jPrev;
-  jPrev[nextSymbol] = i;
+  i.prev = jPrev;
+  jPrev.next = i;
 }
 
-function* setElementIterator(i: any) {
+function* setElementIterator(i: Entry): Generator<bigint> {
   let j = i;
   do {
-    yield j;
-    j = j[nextSymbol];
+    yield j.value;
+    j = j.next;
   } while (j !== i);
 }
 
-function initializeElement(v: any) {
-  v[parentSymbol] = v;
-  v[rankSymbol] = 0;
-  v[nextSymbol] = v[prevSymbol] = v;
-}
-
-const minSymbol = Symbol("disjoint_sets:min");
-
-function isRootElement(v: any) {
-  return v[parentSymbol] === v;
+function isRootElement(v: Entry) {
+  return v.parent === v;
 }
 
 /**
- * Represents a collection of disjoint sets of Uint64 values.
+ * Represents a collection of disjoint sets of uint64 values.
  *
- * Supports merging sets, retrieving the minimum Uint64 value contained in a set (the representative
+ * Supports merging sets, retrieving the minimum uint64 value contained in a set (the representative
  * value), and iterating over the elements contained in a set.
  */
 export class DisjointUint64Sets {
-  private map = new Map<string, Uint64>();
+  private map = new Map<bigint, Entry>();
   visibleSegmentEquivalencePolicy: WatchableValueInterface<VisibleSegmentEquivalencePolicy> =
     new WatchableValue<VisibleSegmentEquivalencePolicy>(
       VisibleSegmentEquivalencePolicy.MIN_REPRESENTATIVE,
     );
   generation = 0;
 
-  has(x: Uint64): boolean {
-    const key = x.toString();
-    const element = this.map.get(key);
-    return element !== undefined;
+  has(x: bigint): boolean {
+    return this.map.has(x);
   }
 
-  get(x: Uint64): Uint64 {
-    const key = x.toString();
-    const element = this.map.get(key);
-    if (element === undefined) {
+  get(x: bigint): bigint {
+    const entry = this.map.get(x);
+    if (entry === undefined) {
       return x;
     }
-    return findRepresentative(element)[minSymbol];
+    return findRepresentative(entry).min;
   }
 
-  isMinElement(x: Uint64) {
-    const y = this.get(x);
-    return y === x || Uint64.equal(y, x);
+  isMinElement(x: bigint) {
+    return x === this.get(x);
   }
 
-  private makeSet(x: Uint64): Uint64 {
-    const key = x.toString();
+  private makeSet(x: bigint): Entry {
     const { map } = this;
-    let element = map.get(key);
-    if (element === undefined) {
-      element = x.clone();
-      initializeElement(element);
-      (<any>element)[minSymbol] = element;
-      map.set(key, element);
-      return element;
+    let entry = map.get(x);
+    if (entry === undefined) {
+      entry = new Entry(x);
+      map.set(x, entry);
+      return entry;
     }
-    return findRepresentative(element);
+    return findRepresentative(entry);
   }
 
   /**
    * Union the sets containing `a` and `b`.
    * @returns `false` if `a` and `b` are already in the same set, otherwise `true`.
    */
-  link(a: Uint64, b: Uint64): boolean {
-    a = this.makeSet(a);
-    b = this.makeSet(b);
-    if (a === b) {
+  link(a: bigint, b: bigint): boolean {
+    const aEntry = this.makeSet(a);
+    const bEntry = this.makeSet(b);
+    if (aEntry === bEntry) {
       return false;
     }
     this.generation++;
-    const newNode = linkUnequalSetRepresentatives(a, b);
-    spliceCircularLists(a, b);
-    const aMin = (<any>a)[minSymbol];
-    const bMin = (<any>b)[minSymbol];
+    const newNode = linkUnequalSetRepresentatives(aEntry, bEntry);
+    spliceCircularLists(aEntry, bEntry);
+    const aMin = aEntry.min;
+    const bMin = bEntry.min;
     const isMax =
       (this.visibleSegmentEquivalencePolicy.value &
         VisibleSegmentEquivalencePolicy.MAX_REPRESENTATIVE) !==
       0;
-    newNode[minSymbol] = Uint64.less(aMin, bMin) === isMax ? bMin : aMin;
+    newNode.min = aMin < bMin === isMax ? bMin : aMin;
     return true;
   }
 
-  linkAll(ids: Uint64[]) {
+  linkAll(ids: bigint[]) {
     for (let i = 1, length = ids.length; i < length; ++i) {
       this.link(ids[0], ids[i]);
     }
@@ -171,11 +163,11 @@ export class DisjointUint64Sets {
   /**
    * Unlinks all members of the specified set.
    */
-  deleteSet(x: Uint64) {
+  deleteSet(x: bigint) {
     const { map } = this;
     let changed = false;
     for (const y of this.setElements(x)) {
-      map.delete(y.toString());
+      map.delete(y);
       changed = true;
     }
     if (changed) {
@@ -184,13 +176,12 @@ export class DisjointUint64Sets {
     return changed;
   }
 
-  *setElements(a: Uint64): IterableIterator<Uint64> {
-    const key = a.toString();
-    const element = this.map.get(key);
-    if (element === undefined) {
+  *setElements(a: bigint): IterableIterator<bigint> {
+    const entry = this.map.get(a);
+    if (entry === undefined) {
       yield a;
     } else {
-      yield* setElementIterator(element);
+      yield* setElementIterator(entry);
     }
   }
 
@@ -208,23 +199,21 @@ export class DisjointUint64Sets {
     return this.map.size;
   }
 
-  *mappings(temp = <[Uint64, Uint64]>new Array<Uint64>(2)) {
-    for (const element of this.map.values()) {
-      temp[0] = element;
-      temp[1] = findRepresentative(element)[minSymbol];
-      yield temp;
+  *mappings(): IterableIterator<[bigint, bigint]> {
+    for (const entry of this.map.values()) {
+      yield [entry.value, findRepresentative(entry).min];
     }
   }
 
-  *roots() {
-    for (const element of this.map.values()) {
-      if (isRootElement(element)) {
-        yield element;
+  *roots(): IterableIterator<bigint> {
+    for (const entry of this.map.values()) {
+      if (isRootElement(entry)) {
+        yield entry.value;
       }
     }
   }
 
-  [Symbol.iterator]() {
+  [Symbol.iterator](): IterableIterator<[bigint, bigint]> {
     return this.mappings();
   }
 
@@ -235,18 +224,18 @@ export class DisjointUint64Sets {
    * order of their smallest elements.
    */
   toJSON(): string[][] {
-    const sets = new Array<Uint64[]>();
-    for (const element of this.map.values()) {
-      if (isRootElement(element)) {
-        const members = new Array<Uint64>();
-        for (const member of setElementIterator(element)) {
+    const sets = new Array<bigint[]>();
+    for (const entry of this.map.values()) {
+      if (isRootElement(entry)) {
+        const members = new Array<bigint>();
+        for (const member of setElementIterator(entry)) {
           members.push(member);
         }
-        members.sort(Uint64.compare);
+        members.sort(bigintCompare);
         sets.push(members);
       }
     }
-    sets.sort((a, b) => Uint64.compare(a[0], b[0]));
+    sets.sort((a, b) => bigintCompare(a[0], b[0]));
     return sets.map((set) => set.map((element) => element.toString()));
   }
 }
diff --git a/src/util/empirical_cdf.browser_test.ts b/src/util/empirical_cdf.browser_test.ts
index eb4b7d3e33..6aebce6e4b 100644
--- a/src/util/empirical_cdf.browser_test.ts
+++ b/src/util/empirical_cdf.browser_test.ts
@@ -23,15 +23,14 @@ import {
   dataTypeIntervalEqual,
   defaultDataTypeRange,
 } from "#src/util/lerp.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 // The first and last bin are for values below the lower bound/above the upper
 // To simulate output from the GLSL shader function on CPU
 function countDataInBins(
-  inputData: (number | Uint64)[],
+  inputData: (number | bigint)[],
   dataType: DataType,
-  min: number | Uint64,
-  max: number | Uint64,
+  min: number | bigint,
+  max: number | bigint,
   numDataBins: number = 254,
 ): Float32Array {
   // Total number of bins is numDataBins + 2, one for values below the lower
@@ -39,10 +38,8 @@ function countDataInBins(
   const counts = new Float32Array(numDataBins + 2).fill(0);
   let binSize: number;
   let binIndex: number;
-  const numerator64 = new Uint64();
   if (dataType === DataType.UINT64) {
-    Uint64.subtract(numerator64, max as Uint64, min as Uint64);
-    binSize = numerator64.toNumber() / numDataBins;
+    binSize = Number((max as bigint) - (min as bigint)) / numDataBins;
   } else {
     binSize = ((max as number) - (min as number)) / numDataBins;
   }
@@ -54,8 +51,9 @@ function countDataInBins(
       counts[numDataBins + 1]++;
     } else {
       if (dataType === DataType.UINT64) {
-        Uint64.subtract(numerator64, value as Uint64, min as Uint64);
-        binIndex = Math.floor(numerator64.toNumber() / binSize);
+        binIndex = Math.floor(
+          Number((value as bigint) - (min as bigint)) / binSize,
+        );
       } else {
         binIndex = Math.floor(((value as number) - (min as number)) / binSize);
       }
@@ -77,7 +75,7 @@ describe("empirical_cdf", () => {
           dataValues,
           dataType,
         );
-        checkPercentileAccuracy(dataRange, range, dataType);
+        checkPercentileAccuracy(dataRange, range);
       });
     }
   }
@@ -93,7 +91,7 @@ describe("empirical_cdf", () => {
           dataValues,
           dataType,
         );
-        checkPercentileAccuracy(dataRange, range, dataType);
+        checkPercentileAccuracy(dataRange, range);
       });
     }
   }
@@ -111,7 +109,7 @@ describe("empirical_cdf", () => {
           dataValues,
           dataType,
         );
-        checkPercentileAccuracy(dataRange, range, dataType, 0, 1, tolerance);
+        checkPercentileAccuracy(dataRange, range, 0, 1, tolerance);
       });
     }
   }
@@ -131,13 +129,7 @@ describe("empirical_cdf", () => {
           minPercentile,
           maxPercentile,
         );
-        checkPercentileAccuracy(
-          dataRange,
-          range,
-          dataType,
-          minPercentile,
-          maxPercentile,
-        );
+        checkPercentileAccuracy(dataRange, range, minPercentile, maxPercentile);
       });
     }
   }
@@ -157,13 +149,7 @@ describe("empirical_cdf", () => {
           minPercentile,
           maxPercentile,
         );
-        checkPercentileAccuracy(
-          dataRange,
-          range,
-          dataType,
-          minPercentile,
-          maxPercentile,
-        );
+        checkPercentileAccuracy(dataRange, range, minPercentile, maxPercentile);
       });
     }
   }
@@ -188,7 +174,6 @@ describe("empirical_cdf", () => {
         checkPercentileAccuracy(
           dataRange,
           range,
-          dataType,
           minPercentile,
           maxPercentile,
           tolerance,
@@ -219,7 +204,7 @@ function findPercentilesFromIterativeHistogram(
 ) {
   const data =
     inputDataType === DataType.UINT64
-      ? inputDataValues.map((v) => Uint64.fromNumber(v))
+      ? inputDataValues.map(BigInt)
       : inputDataValues;
   let numIterations = 0;
   const startRange = determineInitialDataRange(inputDataType);
@@ -241,10 +226,7 @@ function findPercentilesFromIterativeHistogram(
       inputDataType,
     ).range;
     ++numIterations;
-  } while (
-    !dataTypeIntervalEqual(inputDataType, oldRange, newRange) &&
-    numIterations < 32
-  );
+  } while (!dataTypeIntervalEqual(oldRange, newRange) && numIterations < 32);
   expect(numIterations, "Too many iterations").toBeLessThan(16);
   return newRange;
 }
@@ -252,19 +234,12 @@ function findPercentilesFromIterativeHistogram(
 function checkPercentileAccuracy(
   actualDataRange: [number, number],
   computedPercentiles: DataTypeInterval,
-  inputDataType: DataType,
   minPercentile: number = 0.0,
   maxPercentile: number = 1.0,
   tolerance: number = 0,
 ) {
-  const min =
-    inputDataType === DataType.UINT64
-      ? (computedPercentiles[0] as Uint64).toNumber()
-      : (computedPercentiles[0] as number);
-  const max =
-    inputDataType === DataType.UINT64
-      ? (computedPercentiles[1] as Uint64).toNumber()
-      : (computedPercentiles[1] as number);
+  const min = Number(computedPercentiles[0]);
+  const max = Number(computedPercentiles[1]);
   const diff = actualDataRange[1] - actualDataRange[0];
   const correctRange = [
     actualDataRange[0] + minPercentile * diff,
diff --git a/src/util/empirical_cdf.ts b/src/util/empirical_cdf.ts
index e11a6c0ede..07ea457f8f 100644
--- a/src/util/empirical_cdf.ts
+++ b/src/util/empirical_cdf.ts
@@ -21,7 +21,6 @@ import {
   defaultDataTypeRange,
   type DataTypeInterval,
 } from "#src/util/lerp.js";
-import { Uint64 } from "#src/util/uint64.js";
 
 const BIN_SIZE_MULTIPLIER_FOR_WINDOW = 64;
 
@@ -47,28 +46,18 @@ function calculateEmpiricalCdf(histogram: Float32Array): Float32Array | null {
 function calculateBinSize(
   histogram: Float32Array,
   histogramRange: DataTypeInterval,
-  inputDataType: DataType,
 ): number {
   const totalBins = histogram.length - 2; // Exclude the first and last bins.
-  if (inputDataType === DataType.UINT64) {
-    const numerator64 = new Uint64();
-    const min = histogramRange[0] as Uint64;
-    const max = histogramRange[1] as Uint64;
-    Uint64.subtract(numerator64, max, min);
-    return numerator64.toNumber() / totalBins;
-  } else {
-    const min = histogramRange[0] as number;
-    const max = histogramRange[1] as number;
-    return (max - min) / totalBins;
-  }
+  const [minValue, maxValue] = histogramRange as [any, any];
+  return Number(maxValue - minValue) / totalBins;
 }
 
 function adjustBound(
-  bound: number | Uint64,
+  bound: number | bigint,
   dataType: DataType,
   change: number,
   increase: boolean,
-): number | Uint64 {
+): number | bigint {
   const maxDataRange = defaultDataTypeRange[dataType];
 
   // If the bound is already at the limit, don't adjust it.
@@ -81,15 +70,11 @@ function adjustBound(
 
   // Adjust the bound by the change amount up or down.
   const delta = dataType === DataType.FLOAT32 ? change : Math.round(change);
-  const temp = new Uint64();
+  const signedDelta = delta * (increase ? 1 : -1);
   const adjustedBound =
     dataType === DataType.UINT64
-      ? increase
-        ? Uint64.add(temp, bound as Uint64, Uint64.fromNumber(delta))
-        : Uint64.subtract(temp, bound as Uint64, Uint64.fromNumber(delta))
-      : increase
-        ? (bound as number) + delta
-        : (bound as number) - delta;
+      ? (bound as bigint) + BigInt(Math.round(signedDelta))
+      : (bound as number) + signedDelta;
 
   // Ensure the bound is within the data type's range.
   if (dataType === DataType.FLOAT32) {
@@ -99,18 +84,18 @@ function adjustBound(
 }
 
 function decreaseBound(
-  bound: number | Uint64,
+  bound: number | bigint,
   dataType: DataType,
   change: number,
-): number | Uint64 {
+): number | bigint {
   return adjustBound(bound, dataType, change, false);
 }
 
 function increaseBound(
-  bound: number | Uint64,
+  bound: number | bigint,
   dataType: DataType,
   change: number,
-): number | Uint64 {
+): number | bigint {
   return adjustBound(bound, dataType, change, true);
 }
 
@@ -145,7 +130,7 @@ export function computePercentilesFromEmpiricalHistogram(
   if (cdf === null) {
     return { range: histogramRange, window: histogramRange };
   }
-  const binSize = calculateBinSize(histogram, histogramRange, inputDataType);
+  const binSize = calculateBinSize(histogram, histogramRange);
 
   // Find the indices of the percentiles.
   let lowerIndex = 0;
diff --git a/src/util/hash.ts b/src/util/hash.ts
index 964c6283af..21e1bb4d8a 100644
--- a/src/util/hash.ts
+++ b/src/util/hash.ts
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import type { Uint64 } from "#src/util/uint64.js";
-
 /**
  * This is a very simple string hash function.  It isn't secure, but
  * is suitable for sharding of requests.
@@ -69,6 +67,16 @@ export function murmurHash3_x86_32Hash64Bits(
   return murmurHash3_x86_32Finalize(h, 8);
 }
 
+export function murmurHash3_x86_32Hash64Bits_Bigint(
+  seed: number,
+  x: bigint,
+): number {
+  let h = seed;
+  h = murmurHash3_x86_32Mix(h, Number(x & 0xffffffffn));
+  h = murmurHash3_x86_32Mix(h, Number(x >> 32n));
+  return murmurHash3_x86_32Finalize(h, 8);
+}
+
 function murmurHash3_x86_128Mix(h: number) {
   h ^= h >>> 16;
   h = Math.imul(h, 0x85ebca6b);
@@ -87,63 +95,6 @@ function rotl32(x: number, r: number) {
  *
  * Only the low 8 bytes of output are returned.
  */
-export function murmurHash3_x86_128Hash64Bits(
-  out: Uint64,
-  seed: number,
-  low: number,
-  high: number,
-): Uint64 {
-  let h1 = seed;
-  let h2 = seed;
-  let h3 = seed;
-  let h4 = seed;
-  const c1 = 0x239b961b;
-  const c2 = 0xab0e9789;
-  const c3 = 0x38b34ae5;
-  // const c4 = 0xa1e38b93;
-
-  let k2 = Math.imul(high, c2);
-  k2 = rotl32(k2, 16);
-  k2 = Math.imul(k2, c3);
-  h2 ^= k2;
-
-  let k1 = Math.imul(low, c1);
-  k1 = rotl32(k1, 15);
-  k1 = Math.imul(k1, c2);
-  h1 ^= k1;
-
-  const len = 8;
-
-  h1 ^= len;
-  h2 ^= len;
-  h3 ^= len;
-  h4 ^= len;
-
-  h1 = (h1 + h2) >>> 0;
-  h1 = (h1 + h3) >>> 0;
-  h1 = (h1 + h4) >>> 0;
-  h2 = (h2 + h1) >>> 0;
-  h3 = (h3 + h1) >>> 0;
-  h4 = (h4 + h1) >>> 0;
-
-  h1 = murmurHash3_x86_128Mix(h1);
-  h2 = murmurHash3_x86_128Mix(h2);
-  h3 = murmurHash3_x86_128Mix(h3);
-  h4 = murmurHash3_x86_128Mix(h4);
-
-  h1 = (h1 + h2) >>> 0;
-  h1 = (h1 + h3) >>> 0;
-  h1 = (h1 + h4) >>> 0;
-  h2 = (h2 + h1) >>> 0;
-
-  // h3 = (h3 + h1) >>> 0;
-  // h4 = (h4 + h1) >>> 0;
-
-  out.low = h1;
-  out.high = h2;
-  return out;
-}
-
 export function murmurHash3_x86_128Hash64Bits_Bigint(
   seed: number,
   input: bigint,
diff --git a/src/util/json.ts b/src/util/json.ts
index 793ad16041..7613d61ba5 100644
--- a/src/util/json.ts
+++ b/src/util/json.ts
@@ -15,6 +15,7 @@
  */
 
 import type { WritableArrayLike } from "#src/util/array.js";
+import { UINT64_MAX } from "#src/util/bigint.js";
 import { vec3 } from "#src/util/geom.js";
 
 export function verifyFloat(obj: any): number {
@@ -740,9 +741,44 @@ export function verifyOptionalFixedLengthArrayOfStringOrNull(
   return parseFixedLengthArray(new Array<string | null>(rank), obj, (value) => {
     if (value !== null && typeof value !== "string") {
       throw new Error(
-        `Expected string or null, but received: ${JSON.stringify(name)}`,
+        `Expected string or null, but received: ${JSON.stringify(value)}`,
       );
     }
     return value;
   });
 }
+
+export function parseUint64(obj: unknown) {
+  let n: bigint;
+  switch (typeof obj) {
+    case "string":
+      if (obj.match(/^(?:0|[1-9][0-9]*)$/) === null) {
+        throw new Error(
+          `Expected base-10 number, but received: ${JSON.stringify(obj)}`,
+        );
+      }
+      n = BigInt(obj);
+      break;
+    case "number":
+      n = BigInt(obj);
+      break;
+    case "bigint":
+      n = obj;
+      break;
+    default:
+      throw new Error(
+        `Expected uint64 value, but received: ${JSON.stringify(obj)}`,
+      );
+  }
+  if (n < 0n || n > UINT64_MAX) {
+    throw new Error(`Expected uint64 value, but received: ${n}`);
+  }
+  return n;
+}
+
+export function bigintToStringJsonReplacer(_key: unknown, value: unknown) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
diff --git a/src/util/lerp.ts b/src/util/lerp.ts
index c8cc7558cd..b7ead565b1 100644
--- a/src/util/lerp.ts
+++ b/src/util/lerp.ts
@@ -14,14 +14,21 @@
  * limitations under the License.
  */
 
+import {
+  bigintAbs,
+  bigintMax,
+  bigintMin,
+  clampToUint64,
+  roundToUint64,
+  UINT64_MAX,
+} from "#src/util/bigint.js";
 import { DataType } from "#src/util/data_type.js";
 import { nextAfterFloat64 } from "#src/util/float.js";
-import { parseFixedLengthArray } from "#src/util/json.js";
-import { Uint64 } from "#src/util/uint64.js";
+import { parseFixedLengthArray, parseUint64 } from "#src/util/json.js";
 
-export type DataTypeInterval = [number, number] | [Uint64, Uint64];
+export type DataTypeInterval = [number, number] | [bigint, bigint];
 
-export type UnknownDataTypeInterval = [number | Uint64, number | Uint64];
+export type UnknownDataTypeInterval = [number | bigint, number | bigint];
 
 export const defaultDataTypeRange: Record<DataType, DataTypeInterval> = {
   [DataType.UINT8]: [0, 0xff],
@@ -30,7 +37,7 @@ export const defaultDataTypeRange: Record<DataType, DataTypeInterval> = {
   [DataType.INT16]: [-0x8000, 0x7fff],
   [DataType.UINT32]: [0, 0xffffffff],
   [DataType.INT32]: [-0x80000000, 0x7fffffff],
-  [DataType.UINT64]: [Uint64.ZERO, new Uint64(0xffffffff, 0xffffffff)],
+  [DataType.UINT64]: [0n, 0xffffffffffffffffn],
   [DataType.FLOAT32]: [0, 1],
 };
 
@@ -42,28 +49,10 @@ export const defaultDataTypeRange: Record<DataType, DataTypeInterval> = {
  */
 export function computeInvlerp(
   range: DataTypeInterval,
-  value: number | Uint64,
+  value: number | bigint,
 ): number {
-  if (typeof value === "number") {
-    const minValue = range[0] as number;
-    const maxValue = range[1] as number;
-    return (value - minValue) / (maxValue - minValue);
-  }
-  const minValue = range[0] as Uint64;
-  const maxValue = range[1] as Uint64;
-  let numerator: number;
-  if (Uint64.compare(value, minValue) < 0) {
-    numerator = -Uint64.subtract(tempUint64, minValue, value).toNumber();
-  } else {
-    numerator = Uint64.subtract(tempUint64, value, minValue).toNumber();
-  }
-  let denominator = Uint64.absDifference(
-    tempUint64,
-    maxValue,
-    minValue,
-  ).toNumber();
-  if (Uint64.compare(minValue, maxValue) > 0) denominator *= -1;
-  return numerator / denominator;
+  const [minValue, maxValue] = range as [any, any];
+  return Number((value as any) - minValue) / Number(maxValue - minValue);
 }
 
 /**
@@ -77,7 +66,7 @@ export function computeLerp(
   range: DataTypeInterval,
   dataType: DataType,
   value: number,
-): number | Uint64 {
+): number | bigint {
   if (typeof range[0] === "number") {
     const minValue = range[0] as number;
     const maxValue = range[1] as number;
@@ -90,41 +79,26 @@ export function computeLerp(
     }
     return result;
   }
-  let minValue = range[0] as Uint64;
-  let maxValue = range[1] as Uint64;
-  if (Uint64.compare(minValue, maxValue) > 0) {
-    [minValue, maxValue] = [maxValue, minValue];
-    value = 1 - value;
-  }
-  const scalar = Uint64.subtract(tempUint64, maxValue, minValue).toNumber();
-  const result = new Uint64();
-  if (value <= 0) {
-    tempUint64.setFromNumber(scalar * -value);
-    Uint64.subtract(result, minValue, Uint64.min(tempUint64, minValue));
-  } else if (value >= 1) {
-    tempUint64.setFromNumber(scalar * (value - 1));
-    Uint64.add(result, maxValue, tempUint64);
-    if (Uint64.less(result, maxValue)) {
-      result.low = result.high = 0xffffffff;
-    }
+  const minValue = range[0] as bigint;
+  const maxValue = range[1] as bigint;
+  const scalar = Number(maxValue - minValue);
+  let result: bigint;
+  if (value >= 1) {
+    result = maxValue + BigInt(Math.round(scalar * (value - 1)));
   } else {
-    tempUint64.setFromNumber(scalar * value);
-    Uint64.add(result, minValue, tempUint64);
-    if (Uint64.less(result, minValue)) {
-      result.low = result.high = 0xffffffff;
-    }
+    result = minValue + BigInt(Math.round(scalar * value));
   }
-  return result;
+  return clampToUint64(result);
 }
 
 export function clampToInterval(
   range: DataTypeInterval,
-  value: number | Uint64,
-): number | Uint64 {
+  value: number | bigint,
+): number | bigint {
   if (typeof value === "number") {
     return Math.min(Math.max(range[0] as number, value), range[1] as number);
   }
-  return Uint64.min(Uint64.max(range[0] as Uint64, value), range[1] as Uint64);
+  return bigintMin(bigintMax(range[0] as bigint, value), range[1] as bigint);
 }
 
 export function getClampedInterval(
@@ -153,19 +127,13 @@ export function normalizeDataTypeInterval(
   return [interval[1], interval[0]] as DataTypeInterval;
 }
 
-export function dataTypeCompare(a: number | Uint64, b: number | Uint64) {
-  if (typeof a === "number") {
-    return (a as number) - (b as number);
-  }
-  return Uint64.compare(a as Uint64, b as Uint64);
+export function dataTypeCompare(a: number | bigint, b: number | bigint) {
+  return (a as any) < (b as any) ? -1 : (a as any) > (b as any) ? 1 : 0;
 }
 
-const tempUint64 = new Uint64();
-const temp2Uint64 = new Uint64();
-
 export function getClosestEndpoint(
   range: DataTypeInterval,
-  value: number | Uint64,
+  value: number | bigint,
 ): number {
   if (typeof value === "number") {
     return Math.abs(value - (range[0] as number)) <
@@ -173,10 +141,8 @@ export function getClosestEndpoint(
       ? 0
       : 1;
   }
-  return Uint64.less(
-    Uint64.absDifference(tempUint64, range[0] as Uint64, value as Uint64),
-    Uint64.absDifference(temp2Uint64, range[1] as Uint64, value as Uint64),
-  )
+  return bigintAbs((range[0] as bigint) - value) <
+    bigintAbs((range[1] as bigint) - value)
     ? 0
     : 1;
 }
@@ -184,7 +150,7 @@ export function getClosestEndpoint(
 export function parseDataTypeValue(
   dataType: DataType,
   x: unknown,
-): number | Uint64 {
+): number | bigint {
   let s: string;
   if (typeof x !== "string") {
     s = "" + x;
@@ -193,7 +159,7 @@ export function parseDataTypeValue(
   }
   switch (dataType) {
     case DataType.UINT64:
-      return Uint64.parseString(s);
+      return parseUint64(s);
     case DataType.FLOAT32: {
       const value = parseFloat(s);
       if (!Number.isFinite(value)) {
@@ -220,16 +186,18 @@ export function parseDataTypeValue(
   }
 }
 
-export function parseUnknownDataTypeValue(x: unknown): number | Uint64 {
+export function parseUnknownDataTypeValue(x: unknown): number | bigint {
   if (typeof x === "number") return x;
   if (typeof x === "string") {
-    const num64 = new Uint64();
     const num = Number(x);
-    if (num64.tryParseString(x)) {
-      if (num.toString() === num64.toString()) {
+    try {
+      const num64 = parseUint64(x);
+      if (num64.toString() === num.toString()) {
         return num;
       }
       return num64;
+    } catch {
+      // Ignore failure to parse as uint64.
     }
     if (!Number.isFinite(num)) {
       throw new Error(`Invalid value: ${JSON.stringify(x)}`);
@@ -257,16 +225,9 @@ export function parseUnknownDataTypeInterval(
 }
 
 export function dataTypeIntervalEqual(
-  dataType: DataType,
   a: DataTypeInterval,
   b: DataTypeInterval,
 ) {
-  if (dataType === DataType.UINT64) {
-    return (
-      Uint64.equal(a[0] as Uint64, b[0] as Uint64) &&
-      Uint64.equal(a[1] as Uint64, b[1] as Uint64)
-    );
-  }
   return a[0] === b[0] && a[1] === b[1];
 }
 
@@ -275,7 +236,7 @@ export function dataTypeIntervalToJson(
   dataType: DataType,
   defaultRange = defaultDataTypeRange[dataType],
 ) {
-  if (dataTypeIntervalEqual(dataType, range, defaultRange)) return undefined;
+  if (dataTypeIntervalEqual(range, defaultRange)) return undefined;
   if (dataType === DataType.UINT64) {
     return [range[0].toString(), range[1].toString()];
   }
@@ -284,20 +245,14 @@ export function dataTypeIntervalToJson(
 
 export function dataTypeValueNextAfter(
   dataType: DataType,
-  value: number | Uint64,
+  value: number | bigint,
   sign: 1 | -1,
-): number | Uint64 {
+): number | bigint {
   switch (dataType) {
     case DataType.FLOAT32:
       return nextAfterFloat64(value as number, sign * Infinity);
     case DataType.UINT64: {
-      const v = value as Uint64;
-      if (sign === -1) {
-        if (v.low === 0 && v.high === 0) return v;
-        return Uint64.decrement(new Uint64(), v);
-      }
-      if (v.low === 0xffffffff && v.high === 0xffffffff) return v;
-      return Uint64.increment(new Uint64(), v);
+      return clampToUint64((value as bigint) + BigInt(sign));
     }
     default: {
       const range = defaultDataTypeRange[dataType] as [number, number];
@@ -322,11 +277,7 @@ export function getIntervalBoundsEffectiveOffset(
     case DataType.UINT64:
       return (
         0.5 /
-        Uint64.absDifference(
-          tempUint64,
-          interval[0] as Uint64,
-          interval[1] as Uint64,
-        ).toNumber()
+        Number(bigintAbs((interval[0] as bigint) - (interval[1] as bigint)))
       );
     default:
       return 0.5 / Math.abs((interval[0] as number) - (interval[1] as number));
@@ -341,11 +292,9 @@ export function getIntervalBoundsEffectiveFraction(
     case DataType.FLOAT32:
       return 1;
     case DataType.UINT64: {
-      const diff = Uint64.absDifference(
-        tempUint64,
-        interval[0] as Uint64,
-        interval[1] as Uint64,
-      ).toNumber();
+      const diff = Number(
+        bigintAbs((interval[0] as bigint) - (interval[1] as bigint)),
+      );
       return diff / (diff + 1);
     }
     default: {
@@ -364,21 +313,13 @@ export function convertDataTypeInterval(
   }
   let [lower, upper] = interval;
   if (dataType === DataType.UINT64) {
-    if (typeof lower === "number") {
-      lower = Uint64.fromNumber(lower);
-    }
-    if (typeof upper === "number") {
-      upper = Uint64.fromNumber(upper);
-    }
-    return [lower, upper];
-  }
-  // Ensure that neither lower nor upper is a `Uint64`.
-  if (typeof lower !== "number") {
-    lower = lower.toNumber();
-  }
-  if (typeof upper !== "number") {
-    upper = upper.toNumber();
+    return [
+      roundToUint64(Number.isNaN(lower) ? 0n : lower),
+      roundToUint64(Number.isNaN(upper) ? UINT64_MAX : upper),
+    ];
   }
+  lower = Number(lower);
+  upper = Number(upper);
   if (dataType !== DataType.FLOAT32) {
     lower = Math.round(lower);
     upper = Math.round(upper);
diff --git a/src/util/npy.spec.ts b/src/util/npy.spec.ts
index e3e9c4efce..f8d9652caf 100644
--- a/src/util/npy.spec.ts
+++ b/src/util/npy.spec.ts
@@ -16,7 +16,7 @@
 
 import fs from "node:fs/promises";
 import path from "node:path";
-import { describe, it, expect } from "vitest";
+import { describe, test, expect } from "vitest";
 import { DataType } from "#src/util/data_type.js";
 import { parseNpy } from "#src/util/npy.js";
 
@@ -42,7 +42,7 @@ describe("parseNpy", () => {
     })),
   ]) {
     for (const npyName of npys) {
-      it(npyName, async () => {
+      test(npyName, async () => {
         const testDataDir = path.resolve(
           import.meta.dirname,
           "..",
@@ -55,9 +55,13 @@ describe("parseNpy", () => {
           await fs.readFile(`${testDataDir}/npy_test.${json}.json`, {
             encoding: "utf-8",
           }),
+          (key, value) =>
+            Number(key).toString() === key && typeof value === "string"
+              ? BigInt(value)
+              : value,
         ) as ExampleSpec;
         const npy = await fs.readFile(`${testDataDir}/npy_test.${npyName}.npy`);
-        checkNpy(example, new Uint8Array(npy));
+        await checkNpy(example, new Uint8Array(npy));
       });
     }
   }
diff --git a/src/util/npy.ts b/src/util/npy.ts
index 12c09c792a..97a28fbba1 100644
--- a/src/util/npy.ts
+++ b/src/util/npy.ts
@@ -25,7 +25,6 @@ import type { DataType } from "#src/util/data_type.js";
 import {
   DATA_TYPE_ARRAY_CONSTRUCTOR,
   DATA_TYPE_BYTES,
-  DATA_TYPE_JAVASCRIPT_ELEMENTS_PER_ARRAY_ELEMENT,
 } from "#src/util/data_type.js";
 import { convertEndian } from "#src/util/endian.js";
 import { pythonLiteralParse } from "#src/util/json.js";
@@ -83,17 +82,14 @@ export function parseNpy(x: Uint8Array<ArrayBuffer>) {
   }
   const { dataType, endianness } = parseNumpyDtype(dtype);
   const bytesPerElement = DATA_TYPE_BYTES[dataType];
-  const javascriptElementsPerArrayElement =
-    DATA_TYPE_JAVASCRIPT_ELEMENTS_PER_ARRAY_ELEMENT[dataType];
   const arrayConstructor = DATA_TYPE_ARRAY_CONSTRUCTOR[dataType];
-  const javascriptElements = javascriptElementsPerArrayElement * numElements;
   if (bytesPerElement * numElements + dataOffset !== x.byteLength) {
     throw new Error("Expected length does not match length of data");
   }
   const data = new arrayConstructor(
     x.buffer,
     x.byteOffset + dataOffset,
-    javascriptElements,
+    numElements,
   ) as TypedNumberArray<ArrayBuffer>;
   convertEndian(data, endianness, bytesPerElement);
   return new NumpyArray(
diff --git a/src/util/uint64.spec.ts b/src/util/uint64.spec.ts
deleted file mode 100644
index 7917b67512..0000000000
--- a/src/util/uint64.spec.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-/**
- * @license
- * Copyright 2016 Google Inc.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { describe, it, expect } from "vitest";
-import { Uint64 } from "#src/util/uint64.js";
-
-describe("uint64", () => {
-  it("less", () => {
-    expect(Uint64.less(new Uint64(0, 0), new Uint64(0, 1))).toBe(true);
-    expect(Uint64.less(new Uint64(1, 1), new Uint64(1, 0))).toBe(false);
-    expect(Uint64.less(new Uint64(1, 1), new Uint64(1, 1))).toBe(false);
-    expect(Uint64.less(new Uint64(0, 1), new Uint64(1, 0))).toBe(false);
-    expect(Uint64.less(new Uint64(1, 0), new Uint64(0, 1))).toBe(true);
-  });
-
-  it("conversion to string", () => {
-    expect(new Uint64(0, 0).toString()).toEqual("0");
-    expect(new Uint64(1, 0).toString()).toEqual("1");
-    expect(new Uint64(0, 1).toString()).toEqual("4294967296");
-    expect(new Uint64(0, 1).toString(3)).toEqual("102002022201221111211");
-    expect(new Uint64(0, 1).toString(2)).toEqual(
-      "100000000000000000000000000000000",
-    );
-    expect(new Uint64(0, 1).toString(36)).toEqual("1z141z4");
-    expect(new Uint64(4294967295, 4294967295).toString()).toEqual(
-      "18446744073709551615",
-    );
-    expect(new Uint64(4294967295, 4294967295).toString(36)).toEqual(
-      "3w5e11264sgsf",
-    );
-    expect(new Uint64(0, 79741775).toString(29)).toEqual("s2276dsssss2");
-  });
-
-  it("conversion from string", () => {
-    expect(new Uint64(0, 0).tryParseString("0")).toBe(true);
-    expect(new Uint64(1, 0).tryParseString("1")).toBe(true);
-    expect(new Uint64(0, 1).tryParseString("4294967296")).toBe(true);
-    expect(new Uint64(0, 1).tryParseString("102002022201221111211", 3)).toBe(
-      true,
-    );
-    expect(
-      new Uint64(0, 1).tryParseString("100000000000000000000000000000000", 2),
-    ).toBe(true);
-    expect(new Uint64(0, 1).tryParseString("1z141z4", 36)).toBe(true);
-    expect(
-      new Uint64(4294967295, 4294967295).tryParseString("18446744073709551615"),
-    ).toBe(true);
-    expect(
-      new Uint64(4294967295, 4294967295).tryParseString("3w5e11264sgsf", 36),
-    ).toBe(true);
-  });
-
-  it("equal", () => {
-    const a = new Uint64(1, 2);
-    const b = new Uint64(1, 2);
-    expect(Uint64.equal(a, b)).toBe(true);
-    expect(Uint64.equal(a, new Uint64(1, 3))).toBe(false);
-    expect(Uint64.equal(a, new Uint64(2, 1))).toBe(false);
-  });
-
-  it("parseString failures", () => {
-    const temp = new Uint64(1, 2);
-    expect(temp.tryParseString(" ")).toBe(false);
-    expect(temp.tryParseString(" 0")).toBe(false);
-    expect(temp.tryParseString("0 ")).toBe(false);
-    expect(temp.tryParseString("z")).toBe(false);
-    expect(temp.tryParseString("2", 2)).toBe(false);
-    expect(temp.tryParseString("18446744073709551616")).toBe(false);
-    expect(temp.tryParseString("1")).toBe(true);
-  });
-
-  it("parseString toString round trip", () => {
-    function check(s: string, base: number) {
-      const x = Uint64.parseString(s, base);
-      const message = `low=${x.low}, high=${x.high}, toString(${base}) = ${x.toString(
-        base,
-      )}, s=${s}`;
-      expect(x.valid(), message).toBe(true);
-      expect(x.toString(base), message).toEqual(s);
-    }
-    check("0", 10);
-    check("1", 10);
-    check("11", 10);
-    check("18446744073709551615", 10);
-    check("3w5e11264sgsf", 36);
-  });
-
-  it("toString parseString round trip", () => {
-    function check(x: Uint64, base: number) {
-      const s = x.toString(base);
-      const y = Uint64.parseString(s, base);
-      const message = `s=${s}, x.low=${x.low}, x.high=${x.high}, y.low=${y.low}, y.high=${y.high}, base=${base}`;
-      expect([y.low, y.high], message).toEqual([x.low, x.high]);
-    }
-    const count = 100;
-    {
-      const u = new Uint64(264762631, 2836123747);
-      expect(u.toString(13)).toEqual("153c9125c642b111b8");
-      check(u, 13);
-    }
-    check(new Uint64(0, 79741775), 29);
-    for (let base = 2; base <= 36; ++base) {
-      for (let i = 0; i < count; ++i) {
-        check(Uint64.random(), base);
-      }
-    }
-  });
-});
diff --git a/src/util/uint64.ts b/src/util/uint64.ts
deleted file mode 100644
index bdcade77fb..0000000000
--- a/src/util/uint64.ts
+++ /dev/null
@@ -1,361 +0,0 @@
-/**
- * @license
- * Copyright 2016 Google Inc.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const randomTempBuffer = new Uint32Array(2);
-
-const trueBase = 0x100000000;
-
-// For dealing with the string representation in base b, we will represent the 64-bit number as
-//
-//   highPrime * intermediateBase[b] + lowPrime,
-//
-// where:
-//
-//   intermediateBaseForBase[b] = Math.pow(b, lowDigitsforBase[b]),
-//
-// and
-//
-//   lowDigitsForBase[b] = Math.floor(Math.log(Math.pow(2,53 - 32)) / Math.log(b)).
-
-interface StringConversionData {
-  lowDigits: number;
-
-  lowBase: number;
-
-  pattern: RegExp;
-}
-
-const stringConversionData: StringConversionData[] = [];
-for (let base = 2; base <= 36; ++base) {
-  const lowDigits = Math.floor(32 / Math.log2(base));
-  const lowBase = base ** lowDigits;
-  let patternString = `^[0-${String.fromCharCode(
-    "0".charCodeAt(0) + Math.min(9, base - 1),
-  )}`;
-  if (base > 10) {
-    patternString += `a-${String.fromCharCode("a".charCodeAt(0) + base - 11)}`;
-    patternString += `A-${String.fromCharCode("A".charCodeAt(0) + base - 11)}`;
-  }
-  const maxDigits = Math.ceil(64 / Math.log2(base));
-  patternString += `]{1,${maxDigits}}$`;
-  const pattern = new RegExp(patternString);
-  stringConversionData[base] = { lowDigits, lowBase, pattern };
-}
-
-/**
- * Returns the high 32 bits of the result of the 32-bit integer multiply `a` and `b`.
- *
- * The low 32-bits can be obtained using the built-in `Math.imul` function.
- */
-function uint32MultiplyHigh(a: number, b: number) {
-  a >>>= 0;
-  b >>>= 0;
-
-  const a00 = a & 0xffff;
-  const a16 = a >>> 16;
-  const b00 = b & 0xffff;
-  const b16 = b >>> 16;
-
-  const c00 = a00 * b00;
-  let c16 = (c00 >>> 16) + a16 * b00;
-  let c32 = c16 >>> 16;
-  c16 = (c16 & 0xffff) + a00 * b16;
-  c32 += c16 >>> 16;
-  let c48 = c32 >>> 16;
-  c32 = (c32 & 0xffff) + a16 * b16;
-  c48 += c32 >>> 16;
-
-  return (((c48 & 0xffff) << 16) | (c32 & 0xffff)) >>> 0;
-}
-
-export class Uint64 {
-  constructor(
-    public low = 0,
-    public high = 0,
-  ) {}
-
-  clone() {
-    return new Uint64(this.low, this.high);
-  }
-
-  assign(x: Uint64) {
-    this.low = x.low;
-    this.high = x.high;
-  }
-
-  toString(base = 10): string {
-    const vLow = this.low;
-    const vHigh = this.high;
-    if (vHigh === 0) {
-      return vLow.toString(base);
-    }
-    return this.toBigInt().toString(base);
-  }
-
-  /**
-   * Returns true if a is strictly less than b.
-   */
-  static less(a: Uint64, b: Uint64): boolean {
-    return a.high < b.high || (a.high === b.high && a.low < b.low);
-  }
-
-  /**
-   * Returns a negative number if a is strictly less than b, 0 if a is equal to b, or a positive
-   * number if a is strictly greater than b.
-   */
-  static compare(a: Uint64, b: Uint64): number {
-    return a.high - b.high || a.low - b.low;
-  }
-
-  static ZERO = new Uint64(0, 0);
-  static ONE = new Uint64(1, 0);
-
-  static equal(a: Uint64, b: Uint64) {
-    return a.low === b.low && a.high === b.high;
-  }
-
-  static min(a: Uint64, b: Uint64): Uint64 {
-    return Uint64.less(a, b) ? a : b;
-  }
-
-  static max(a: Uint64, b: Uint64): Uint64 {
-    return Uint64.less(a, b) ? b : a;
-  }
-
-  static random() {
-    crypto.getRandomValues(randomTempBuffer);
-    return new Uint64(randomTempBuffer[0], randomTempBuffer[1]);
-  }
-
-  tryParseString(s: string, base = 10) {
-    const { lowDigits, lowBase, pattern } = stringConversionData[base];
-    if (!pattern.test(s)) {
-      return false;
-    }
-    if (s.length <= lowDigits) {
-      this.low = parseInt(s, base);
-      this.high = 0;
-      return true;
-    }
-    const splitPoint = s.length - lowDigits;
-    const lowPrime = parseInt(s.substr(splitPoint), base);
-    const highPrime = parseInt(s.substr(0, splitPoint), base);
-
-    let high: number;
-    let low: number;
-
-    if (lowBase === trueBase) {
-      high = highPrime;
-      low = lowPrime;
-    } else {
-      const highRemainder = Math.imul(highPrime, lowBase) >>> 0;
-      high =
-        uint32MultiplyHigh(highPrime, lowBase) +
-        (Math.imul(Math.floor(highPrime / trueBase), lowBase) >>> 0);
-      low = lowPrime + highRemainder;
-      if (low >= trueBase) {
-        ++high;
-        low -= trueBase;
-      }
-    }
-    if (low >>> 0 !== low || high >>> 0 !== high) {
-      return false;
-    }
-    this.low = low;
-    this.high = high;
-    return true;
-  }
-
-  parseString(s: string, base = 10) {
-    if (!this.tryParseString(s, base)) {
-      throw new Error(
-        `Failed to parse string as uint64 value: ${JSON.stringify(s)}.`,
-      );
-    }
-    return this;
-  }
-
-  static parseString(s: string, base = 10) {
-    const x = new Uint64();
-    return x.parseString(s, base);
-  }
-
-  valid() {
-    const { low, high } = this;
-    return low >>> 0 === low && high >>> 0 === high;
-  }
-
-  toJSON() {
-    return this.toString();
-  }
-
-  static lshift(out: Uint64, input: Uint64, bits: number): Uint64 {
-    const { low, high } = input;
-    if (bits === 0) {
-      out.low = low;
-      out.high = high;
-    } else if (bits < 32) {
-      out.low = low << bits;
-      out.high = (high << bits) | (low >>> (32 - bits));
-    } else {
-      out.low = 0;
-      out.high = low << (bits - 32);
-    }
-    return out;
-  }
-
-  static rshift(out: Uint64, input: Uint64, bits: number) {
-    const { low, high } = input;
-    if (bits === 0) {
-      out.low = low;
-      out.high = high;
-    } else if (bits < 32) {
-      out.low = (low >>> bits) | (high << (32 - bits));
-      out.high = high >>> bits;
-    } else {
-      out.low = high >>> (bits - 32);
-      out.high = 0;
-    }
-    return out;
-  }
-
-  static or(out: Uint64, a: Uint64, b: Uint64): Uint64 {
-    out.low = a.low | b.low;
-    out.high = a.high | b.high;
-    return out;
-  }
-
-  static xor(out: Uint64, a: Uint64, b: Uint64): Uint64 {
-    out.low = a.low ^ b.low;
-    out.high = a.high ^ b.high;
-    return out;
-  }
-
-  static and(out: Uint64, a: Uint64, b: Uint64): Uint64 {
-    out.low = a.low & b.low;
-    out.high = a.high & b.high;
-    return out;
-  }
-
-  static add(out: Uint64, a: Uint64, b: Uint64): Uint64 {
-    const lowSum = a.low + b.low;
-    let highSum = a.high + b.high;
-    const low = lowSum >>> 0;
-    if (low !== lowSum) highSum += 1;
-    out.low = low;
-    out.high = highSum >>> 0;
-    return out;
-  }
-
-  static addUint32(out: Uint64, a: Uint64, b: number): Uint64 {
-    const lowSum = a.low + b;
-    let highSum = a.high;
-    const low = lowSum >>> 0;
-    if (low !== lowSum) highSum += 1;
-    out.low = low;
-    out.high = highSum >>> 0;
-    return out;
-  }
-
-  static decrement(out: Uint64, input: Uint64): Uint64 {
-    let { low, high } = input;
-    if (low === 0) {
-      high -= 1;
-    }
-    out.low = (low - 1) >>> 0;
-    out.high = high >>> 0;
-    return out;
-  }
-
-  static increment(out: Uint64, input: Uint64): Uint64 {
-    let { low, high } = input;
-    if (low === 0xffffffff) high += 1;
-    out.low = (low + 1) >>> 0;
-    out.high = high >>> 0;
-    return out;
-  }
-
-  static subtract(out: Uint64, a: Uint64, b: Uint64): Uint64 {
-    const lowSum = a.low - b.low;
-    let highSum = a.high - b.high;
-    const low = lowSum >>> 0;
-    if (low !== lowSum) highSum -= 1;
-    out.low = low;
-    out.high = highSum >>> 0;
-    return out;
-  }
-
-  static absDifference(out: Uint64, a: Uint64, b: Uint64): Uint64 {
-    return Uint64.less(a, b)
-      ? Uint64.subtract(out, b, a)
-      : Uint64.subtract(out, a, b);
-  }
-
-  static multiplyUint32(out: Uint64, a: Uint64, b: number): Uint64 {
-    const { low, high } = a;
-    out.low = Math.imul(low, b) >>> 0;
-    out.high = (Math.imul(high, b) + uint32MultiplyHigh(low, b)) >>> 0;
-    return out;
-  }
-
-  static lowMask(out: Uint64, bits: number) {
-    if (bits === 0) {
-      out.high = out.low = 0;
-    } else if (bits <= 32) {
-      out.high = 0;
-      out.low = 0xffffffff >>> (32 - bits);
-    } else {
-      out.high = 0xffffffff >>> (bits - 32);
-      out.low = 0xffffffff;
-    }
-    return out;
-  }
-
-  toNumber() {
-    return this.low + this.high * 0x100000000;
-  }
-
-  toBigInt() {
-    return BigInt(this.low) | (BigInt(this.high) << 32n);
-  }
-
-  setFromNumber(value: number) {
-    value = Math.round(value);
-    if (value < 0) {
-      this.low = this.high = 0;
-    } else if (value >= 0x10000000000000000) {
-      this.low = this.high = 0xffffffff;
-    } else {
-      this.low = value % 0x100000000;
-      this.high = Math.floor(value / 0x100000000);
-    }
-  }
-
-  setFromBigInt(value: bigint) {
-    this.low = Number(value & 0xffffffffn);
-    this.high = Number(value >> 32n);
-  }
-
-  static fromNumber(value: number) {
-    const x = new Uint64();
-    x.setFromNumber(value);
-    return x;
-  }
-
-  static fromBigInt(value: bigint) {
-    return new Uint64(Number(value & 0xffffffffn), Number(value >> 32n));
-  }
-}
diff --git a/src/webgl/lerp.browser_test.ts b/src/webgl/lerp.browser_test.ts
index 59be6bc4e1..c859354ffb 100644
--- a/src/webgl/lerp.browser_test.ts
+++ b/src/webgl/lerp.browser_test.ts
@@ -15,7 +15,8 @@
  */
 
 import { expect, describe, it } from "vitest";
-import type { TypedNumberArrayConstructor } from "#src/util/array.js";
+import type { TypedArrayConstructor } from "#src/util/array.js";
+import { bigintAbs } from "#src/util/bigint.js";
 import { DATA_TYPE_ARRAY_CONSTRUCTOR, DataType } from "#src/util/data_type.js";
 import type { DataTypeInterval } from "#src/util/lerp.js";
 import {
@@ -24,7 +25,6 @@ import {
   defaultDataTypeRange,
 } from "#src/util/lerp.js";
 import { getRandomValues } from "#src/util/random.js";
-import { Uint64 } from "#src/util/uint64.js";
 import {
   defineInvlerpShaderFunction,
   defineLerpShaderFunction,
@@ -39,15 +39,14 @@ function getRandomValue(dataType: DataType) {
     case DataType.UINT16:
     case DataType.INT16:
     case DataType.UINT32:
-    case DataType.INT32: {
+    case DataType.INT32:
+    case DataType.UINT64: {
       const buf = new (DATA_TYPE_ARRAY_CONSTRUCTOR[
         dataType
-      ] as TypedNumberArrayConstructor<ArrayBuffer>)(1);
+      ] as TypedArrayConstructor<ArrayBuffer>)(1);
       getRandomValues(buf);
       return buf[0];
     }
-    case DataType.UINT64:
-      return Uint64.random();
     case DataType.FLOAT32:
       return Math.random();
   }
@@ -55,13 +54,6 @@ function getRandomValue(dataType: DataType) {
 
 function getRandomInterval(dataType: DataType): DataTypeInterval {
   while (true) {
-    if (dataType === DataType.UINT64) {
-      const a = Uint64.random();
-      const b = Uint64.random();
-      const c = Uint64.compare(a, b);
-      if (c === 0) continue;
-      return [a, b];
-    }
     const a = getRandomValue(dataType) as number;
     const b = getRandomValue(dataType) as number;
     if (a === b) continue;
@@ -69,12 +61,10 @@ function getRandomInterval(dataType: DataType): DataTypeInterval {
   }
 }
 
-const u64 = Uint64.parseString;
-
 function testInvlerpRoundtrip(
   dataType: DataType,
   interval: DataTypeInterval,
-  values: (number | Uint64)[],
+  values: (number | bigint)[],
 ) {
   for (const x of values) {
     const t = computeInvlerp(interval, x);
@@ -86,15 +76,11 @@ function testInvlerpRoundtrip(
   }
 }
 
-function getAbsDifference(a: number | Uint64, b: number | Uint64): number {
+function getAbsDifference(a: number | bigint, b: number | bigint): number {
   if (typeof a === "number") {
     return Math.abs(a - (b as number));
   }
-  return Uint64.absDifference(
-    new Uint64(),
-    a as Uint64,
-    b as Uint64,
-  ).toNumber();
+  return Number(bigintAbs(a - (b as bigint)));
 }
 
 function getLerpErrorBound(interval: DataTypeInterval, dataType: DataType) {
@@ -159,7 +145,7 @@ function testRoundtripRandom(
     const interval = getRandomInterval(dataType);
     testInvlerpRoundtrip(dataType, interval, interval);
     {
-      const values: (number | Uint64)[] = [];
+      const values: (number | bigint)[] = [];
       for (let j = 0; j < numInvlerpSamples; ++j) {
         values.push(getRandomValue(dataType));
       }
@@ -207,50 +193,27 @@ describe("computeLerp", () => {
     expect(computeLerp([255, 253], DataType.UINT8, 1)).toEqual(253);
   });
   it("works for uint64", () => {
+    expect(computeLerp([0n, 255n], DataType.UINT64, 0)).toEqual(0n);
+    expect(computeLerp([255n, 0n], DataType.UINT64, 0)).toEqual(255n);
+    expect(computeInvlerp([255n, 0n], 0n)).toEqual(1);
+    expect(computeInvlerp([255n, 0n], 128n)).toBeCloseTo(0.498, 2);
+    expect(computeLerp([0n, 255n], DataType.UINT64, 0.999)).toEqual(255n);
+    expect(computeLerp([0n, 255n], DataType.UINT64, 1.001)).toEqual(255n);
+    expect(computeLerp([0n, 255n], DataType.UINT64, 0.99)).toEqual(252n);
+    expect(computeLerp([0n, 255n], DataType.UINT64, 0.99)).toEqual(252n);
     expect(
-      computeLerp([u64("0"), u64("255")], DataType.UINT64, 0).toString(),
-    ).toEqual("0");
-    expect(
-      computeLerp([u64("255"), u64("0")], DataType.UINT64, 0).toString(),
-    ).toEqual("255");
-    expect(computeInvlerp([u64("255"), u64("0")], u64("0"))).toEqual(1);
-    expect(computeInvlerp([u64("255"), u64("0")], u64("128"))).toBeCloseTo(
-      0.498,
-      2,
-    );
-    expect(
-      computeLerp([u64("0"), u64("255")], DataType.UINT64, 0.999).toString(),
-    ).toEqual("255");
-    expect(
-      computeLerp([u64("0"), u64("255")], DataType.UINT64, 1.001).toString(),
-    ).toEqual("255");
-    expect(
-      computeLerp([u64("0"), u64("255")], DataType.UINT64, 0.99).toString(),
-    ).toEqual("252");
+      computeLerp([0n, 18446744073709551615n], DataType.UINT64, 0.0),
+    ).toEqual(0n);
     expect(
-      computeLerp([u64("0"), u64("255")], DataType.UINT64, 0.99).toString(),
-    ).toEqual("252");
-    expect(
-      computeLerp(
-        [u64("0"), u64("18446744073709551615")],
-        DataType.UINT64,
-        0.0,
-      ).toString(),
-    ).toEqual("0");
-    expect(
-      computeLerp(
-        [u64("0"), u64("18446744073709551615")],
-        DataType.UINT64,
-        1.0,
-      ).toString(),
-    ).toEqual("18446744073709551615");
+      computeLerp([0n, 18446744073709551615n], DataType.UINT64, 1.0),
+    ).toEqual(18446744073709551615n);
     expect(
       computeLerp(
-        [u64("18446744073709551613"), u64("18446744073709551615")],
+        [18446744073709551613n, 18446744073709551615n],
         DataType.UINT64,
         0.5,
-      ).toString(),
-    ).toEqual("18446744073709551614");
+      ),
+    ).toEqual(18446744073709551614n);
   });
   it("round trips for uint8", () => {
     testRoundtripInterval(DataType.UINT8, [0, 255]);
@@ -310,10 +273,7 @@ outputValue = doInvlerp(lerpOutput);
               const { outputValue, lerpOutput } = tester.values;
               return {
                 u: outputValue,
-                x:
-                  typeof lerpOutput === "bigint"
-                    ? Uint64.fromBigInt(lerpOutput)
-                    : (lerpOutput as number),
+                x: lerpOutput,
               };
             };
             testLerpRoundtrip(dataType, interval, 0, roundtrip);
@@ -336,7 +296,7 @@ outputValue = doInvlerp(lerpOutput);
     dataType: DataType,
     examples: {
       interval: DataTypeInterval;
-      values?: (number | Uint64)[] | undefined;
+      values?: (number | bigint)[] | undefined;
     }[],
   ) {
     it(`invlerp->lerp round trips for ${DataType[
@@ -360,7 +320,7 @@ outputValue = doLerp(invlerpOutput);
           const { shader } = tester;
           const testExample = (example: {
             interval: DataTypeInterval;
-            values?: (number | Uint64)[] | undefined;
+            values?: (number | bigint)[] | undefined;
           }) => {
             enableLerpShaderFunction(
               shader,
diff --git a/src/webgl/lerp.ts b/src/webgl/lerp.ts
index ef7a1207ea..80d1f4d8c9 100644
--- a/src/webgl/lerp.ts
+++ b/src/webgl/lerp.ts
@@ -18,9 +18,9 @@
  * @file Defines lerp/invlerp functionality for all supported data types.
  */
 
+import { bigintAbs } from "#src/util/bigint.js";
 import { DataType, DATA_TYPE_SIGNED } from "#src/util/data_type.js";
 import type { DataTypeInterval } from "#src/util/lerp.js";
-import { Uint64 } from "#src/util/uint64.js";
 import type {
   ShaderBuilder,
   ShaderCodePart,
@@ -334,8 +334,6 @@ ${getShaderType(dataType)} ${name}(float inputValue) {
   ];
 }
 
-const tempUint64 = new Uint64();
-
 export function enableLerpShaderFunction(
   shader: ShaderProgram,
   name: string,
@@ -371,21 +369,23 @@ export function enableLerpShaderFunction(
       break;
     }
     case DataType.UINT64: {
-      const lower = interval[0] as Uint64;
-      const upper = interval[1] as Uint64;
-      Uint64.absDifference(tempUint64, upper, lower);
-      const numBits =
-        tempUint64.high > 0
-          ? 32 + Math.ceil(Math.log2(tempUint64.high))
-          : Math.ceil(Math.log2(tempUint64.low));
+      const lower = interval[0] as bigint;
+      const upper = interval[1] as bigint;
+      let diff = bigintAbs(upper - lower);
+      const numBits = Math.ceil(Math.log2(Number(diff)));
       const shift = Math.max(0, numBits - 24);
-      Uint64.rshift(tempUint64, tempUint64, shift);
-      let scalar = 1 / tempUint64.low;
-      if (Uint64.compare(lower, upper) > 0) {
+      diff = diff >> BigInt(shift);
+      let scalar = 1 / Number(diff);
+      if (lower > upper) {
         scalar *= -1;
       }
       const bLocation = shader.uniform(`uLerpBounds_${name}`);
-      gl.uniform3ui(bLocation, lower.low, lower.high, shift);
+      gl.uniform3ui(
+        bLocation,
+        Number(lower & 0xffffffffn),
+        Number(lower >> 32n),
+        shift,
+      );
       gl.uniform1f(shader.uniform(`uLerpScalar_${name}`), scalar);
     }
   }
diff --git a/src/webgl/shader_lib.browser_test.ts b/src/webgl/shader_lib.browser_test.ts
index 38b758228b..f53f0f2e7e 100644
--- a/src/webgl/shader_lib.browser_test.ts
+++ b/src/webgl/shader_lib.browser_test.ts
@@ -16,7 +16,6 @@
 
 import { describe, it, expect } from "vitest";
 import { DataType } from "#src/util/data_type.js";
-import { Uint64 } from "#src/util/uint64.js";
 import {
   glsl_addSaturateInt32,
   glsl_addSaturateUint32,
@@ -176,7 +175,6 @@ describe("int32SubtractSaturate", () => {
 });
 
 describe("uint64AddSaturate", () => {
-  const u64 = Uint64.parseString;
   it("works for examples", () => {
     fragmentShaderTest(
       { inputA: DataType.UINT64, inputB: DataType.UINT64 },
@@ -187,20 +185,20 @@ describe("uint64AddSaturate", () => {
         builder.setFragmentMain("outputValue = addSaturate(inputA, inputB);");
 
         for (const [a, b, expected] of [
-          ["0", "0", "0"],
-          ["1", "2", "3"],
-          ["fffffffffffffffd", "1", "fffffffffffffffe"],
-          ["fffffffffffffffd", "2", "ffffffffffffffff"],
-          ["fffffffffffffffd", "3", "ffffffffffffffff"],
-          ["1", "fffffffffffffffd", "fffffffffffffffe"],
-          ["2", "fffffffffffffffd", "ffffffffffffffff"],
-          ["3", "fffffffffffffffd", "ffffffffffffffff"],
-          ["1", "ffffffffffffffff", "ffffffffffffffff"],
+          [0n, 0n, 0n],
+          [1n, 2n, 3n],
+          [0xfffffffffffffffdn, 1n, 0xfffffffffffffffen],
+          [0xfffffffffffffffdn, 2n, 0xffffffffffffffffn],
+          [0xfffffffffffffffdn, 3n, 0xffffffffffffffffn],
+          [1n, 0xfffffffffffffffdn, 0xfffffffffffffffen],
+          [2n, 0xfffffffffffffffdn, 0xffffffffffffffffn],
+          [3n, 0xfffffffffffffffdn, 0xffffffffffffffffn],
+          [1n, 0xffffffffffffffffn, 0xffffffffffffffffn],
         ]) {
           const msg = `addSaturate(${a}, ${b}) = ${expected}`;
-          tester.execute({ inputA: u64(a, 16), inputB: u64(b, 16) });
+          tester.execute({ inputA: a, inputB: b });
           const result = tester.values.outputValue;
-          expect(result.toString(16), msg).toBe(u64(expected, 16).toString(16));
+          expect(result, msg).toEqual(expected);
         }
       },
     );
diff --git a/src/webgl/shader_testing.ts b/src/webgl/shader_testing.ts
index 9799814fbd..23f911b61d 100644
--- a/src/webgl/shader_testing.ts
+++ b/src/webgl/shader_testing.ts
@@ -16,7 +16,6 @@
 
 import { DataType } from "#src/util/data_type.js";
 import { RefCounted } from "#src/util/disposable.js";
-import { Uint64 } from "#src/util/uint64.js";
 import type { GL } from "#src/webgl/context.js";
 import {
   FramebufferConfiguration,
@@ -39,7 +38,7 @@ export interface FragmentShaderTestOutputs {
 
 export type ShaderIoJavascriptType<T extends ShaderIoType> = T extends DataType
   ? T extends DataType.UINT64
-    ? bigint | Uint64
+    ? bigint
     : number
   : T extends "bool"
     ? boolean
@@ -254,8 +253,7 @@ void main() {
             gl.uniform1f(shader.uniform(key), value);
             break;
           case DataType.UINT64: {
-            const v =
-              value instanceof Uint64 ? value.toBigInt() : BigInt(value);
+            const v = BigInt(value);
             gl.uniform2ui(
               shader.uniform(`ngin_${key}`),
               Number(v & 0xffffffffn),
diff --git a/src/webgl/shader_ui_controls.browser_test.ts b/src/webgl/shader_ui_controls.browser_test.ts
index 759d109f72..add39bd56b 100644
--- a/src/webgl/shader_ui_controls.browser_test.ts
+++ b/src/webgl/shader_ui_controls.browser_test.ts
@@ -18,7 +18,6 @@ import { expect, describe, it } from "vitest";
 import { DataType } from "#src/util/data_type.js";
 import { vec3, vec4 } from "#src/util/geom.js";
 import { defaultDataTypeRange } from "#src/util/lerp.js";
-import { Uint64 } from "#src/util/uint64.js";
 import {
   TrackableTransferFunctionParameters,
   parseShaderUiControls,
@@ -860,15 +859,9 @@ void main() {
 }
 `;
     const controlPoints = [
-      new ControlPoint(
-        Uint64.parseString("9223372111111111111"),
-        vec4.fromValues(255, 0, 0, 128),
-      ),
-      new ControlPoint(Uint64.fromNumber(0), vec4.fromValues(0, 0, 0, 0)),
-      new ControlPoint(
-        Uint64.parseString("18446744073709551615"),
-        vec4.fromValues(0, 255, 0, 26),
-      ),
+      new ControlPoint(9223372111111111111n, vec4.fromValues(255, 0, 0, 128)),
+      new ControlPoint(0n, vec4.fromValues(0, 0, 0, 0)),
+      new ControlPoint(18446744073709551615n, vec4.fromValues(0, 255, 0, 26)),
     ];
     const sortedControlPoints = new SortedControlPoints(
       controlPoints,
@@ -892,7 +885,7 @@ void main() {
               sortedControlPoints: sortedControlPoints,
               channel: [],
               defaultColor: vec3.fromValues(0, 0, 1),
-              window: [Uint64.fromNumber(0), Uint64.fromNumber(2000)],
+              window: [0n, 2000n],
             },
           },
         ],
@@ -958,9 +951,9 @@ void main() {
     // Test setting a new control point
     const sortedControlPoints = new SortedControlPoints(
       [
-        new ControlPoint(Uint64.fromNumber(0), vec4.fromValues(0, 0, 0, 10)),
+        new ControlPoint(0n, vec4.fromValues(0, 0, 0, 10)),
         new ControlPoint(
-          Uint64.parseString("18446744073709551615"),
+          18446744073709551615n,
           vec4.fromValues(255, 255, 255, 255),
         ),
       ],
diff --git a/src/webgl/shader_ui_controls.ts b/src/webgl/shader_ui_controls.ts
index 4feb3051de..23d3126798 100644
--- a/src/webgl/shader_ui_controls.ts
+++ b/src/webgl/shader_ui_controls.ts
@@ -57,7 +57,6 @@ import {
 } from "#src/util/lerp.js";
 import { NullarySignal } from "#src/util/signal.js";
 import type { Trackable } from "#src/util/trackable.js";
-import type { Uint64 } from "#src/util/uint64.js";
 import type { GL } from "#src/webgl/context.js";
 import type { HistogramChannelSpecification } from "#src/webgl/empirical_cdf.js";
 import { HistogramSpecifications } from "#src/webgl/empirical_cdf.js";
@@ -832,15 +831,10 @@ float ${uName}() {
   }
 }
 
-function objectFromEntries(entries: Iterable<[string, any]>) {
-  const obj: any = {};
-  for (const [key, value] of entries) {
-    obj[key] = value;
+function replaceBigintAndMap(_key: string, value: unknown) {
+  if (typeof value === "bigint") {
+    return value.toString();
   }
-  return obj;
-}
-
-function replaceMap(_key: string, value: unknown) {
   if (value instanceof Map) {
     return Array.from(value.entries());
   }
@@ -849,7 +843,7 @@ function replaceMap(_key: string, value: unknown) {
 
 function encodeControls(controls: Controls | undefined) {
   if (controls === undefined) return undefined;
-  return JSON.stringify(objectFromEntries(controls), replaceMap);
+  return JSON.stringify(Object.fromEntries(controls), replaceBigintAndMap);
 }
 
 export class WatchableShaderUiControls
@@ -1144,9 +1138,9 @@ export class TrackableTransferFunctionParameters extends TrackableValue<Transfer
   }
 
   controlPointsToJson(controlPoints: ControlPoint[], dataType: DataType) {
-    function inputToJson(inputValue: number | Uint64) {
+    function inputToJson(inputValue: number | bigint) {
       if (dataType === DataType.UINT64) {
-        return (inputValue as Uint64).toJSON();
+        return inputValue.toString();
       }
       return inputValue;
     }
diff --git a/src/webgl/texture_access.ts b/src/webgl/texture_access.ts
index 76cb61b252..d3a58b5e5d 100644
--- a/src/webgl/texture_access.ts
+++ b/src/webgl/texture_access.ts
@@ -24,6 +24,7 @@
  */
 
 import type {
+  TypedArray,
   TypedNumberArray,
   TypedNumberArrayConstructor,
 } from "#src/util/array.js";
@@ -295,7 +296,7 @@ export function computeTextureFormat(
 export function setOneDimensionalTextureData(
   gl: GL,
   format: TextureFormat,
-  data: TypedNumberArray,
+  data: TypedArray,
 ) {
   const {
     arrayConstructor,
@@ -305,7 +306,11 @@ export function setOneDimensionalTextureData(
     texelsPerElement,
   } = format;
   const { maxTextureSize } = gl;
-  const numElements = data.length / arrayElementsPerTexel;
+  const sourceArrayElementsPerTexel =
+    data.BYTES_PER_ELEMENT /
+    arrayConstructor.BYTES_PER_ELEMENT /
+    arrayElementsPerTexel;
+  const numElements = data.length * sourceArrayElementsPerTexel;
   if (numElements * texelsPerElement > maxTextureSize * maxTextureSize) {
     throw new Error(
       "Number of elements exceeds maximum texture size: " +
@@ -380,7 +385,7 @@ export function setTwoDimensionalTextureData(
 export function setThreeDimensionalTextureData(
   gl: GL,
   format: TextureFormat,
-  data: TypedNumberArray,
+  data: TypedArray,
   width: number,
   height: number,
   depth: number,
diff --git a/src/widget/invlerp.ts b/src/widget/invlerp.ts
index b56381eddc..8b202ca796 100644
--- a/src/widget/invlerp.ts
+++ b/src/widget/invlerp.ts
@@ -45,7 +45,6 @@ import {
 } from "#src/util/lerp.js";
 import { MouseEventBinder } from "#src/util/mouse_bindings.js";
 import { startRelativeMouseDrag } from "#src/util/mouse_drag.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { getWheelZoomAmount } from "#src/util/wheel_zoom.js";
 import type { WatchableVisibilityPriority } from "#src/visibility_priority/frontend.js";
 import { getMemoizedBuffer } from "#src/webgl/buffer.js";
@@ -148,7 +147,7 @@ export class CdfController<
       if (value === undefined) return;
       const clampedRange = getClampedInterval(bounds.window, bounds.range);
       const endpointIndex = getClosestEndpoint(clampedRange, value);
-      const setEndpoint = (value: number | Uint64) => {
+      const setEndpoint = (value: number | bigint) => {
         const bounds = this.getModel();
         this.setModel(
           getUpdatedRangeAndWindowParameters(
@@ -179,7 +178,7 @@ export class CdfController<
         const initialValue = this.getWindowLerp(initialRelativeX);
         // Index for bound being adjusted
         const endpointIndex = initialRelativeX < 0.5 ? 0 : 1;
-        const setEndpoint = (value: number | Uint64) => {
+        const setEndpoint = (value: number | bigint) => {
           const bounds = this.getModel();
           this.setModel(
             getUpdatedRangeAndWindowParameters(
@@ -263,7 +262,7 @@ export class CdfController<
     return computeLerp(this.getModel().window, this.dataType, relativeX);
   }
 
-  getTargetValue(event: MouseEvent): number | Uint64 | undefined {
+  getTargetValue(event: MouseEvent): number | bigint | undefined {
     const targetFraction = this.getTargetFraction(event);
     if (!Number.isFinite(targetFraction)) return undefined;
     return this.getWindowLerp(targetFraction);
@@ -296,7 +295,7 @@ export function getUpdatedRangeAndWindowParameters<
   existingBounds: T,
   boundType: "range" | "window",
   endpointIndex: number,
-  newEndpoint: number | Uint64,
+  newEndpoint: number | bigint,
   fitRangeInWindow = false,
 ): T {
   const newBounds = { ...existingBounds };
@@ -667,10 +666,10 @@ export function updateInputBoundWidth(inputElement: HTMLInputElement) {
 
 export function updateInputBoundValue(
   inputElement: HTMLInputElement,
-  bound: number | Uint64,
+  bound: number | bigint,
 ) {
   let boundString: string;
-  if (bound instanceof Uint64 || Number.isInteger(bound)) {
+  if (typeof bound === "bigint" || Number.isInteger(bound)) {
     boundString = bound.toString();
   } else {
     boundString = bound.toPrecision(6);
@@ -907,7 +906,7 @@ export function activateInvlerpTool(
       const curRange = control.trackable.value.range;
       const curScreenX = newEvent.screenX;
       const curScreenY = newEvent.screenY;
-      if (!dataTypeIntervalEqual(control.dataType, curRange, prevRange)) {
+      if (!dataTypeIntervalEqual(curRange, prevRange)) {
         baseRange = curRange;
         baseScreenX = prevScreenX;
         baseScreenY = prevScreenY;
diff --git a/src/widget/invlerp_range_finder.ts b/src/widget/invlerp_range_finder.ts
index e3e445392a..034de1b9e4 100644
--- a/src/widget/invlerp_range_finder.ts
+++ b/src/widget/invlerp_range_finder.ts
@@ -171,7 +171,7 @@ export class AutoRangeFinder extends RefCounted {
     let foundRange = false;
     if (dataType !== DataType.FLOAT32) {
       foundRange = autoRangeData.previouslyComputedRanges.some((prevRange) =>
-        dataTypeIntervalEqual(dataType, prevRange, newRange),
+        dataTypeIntervalEqual(prevRange, newRange),
       );
     } else {
       foundRange = autoRangeData.previouslyComputedRanges.some(
diff --git a/src/widget/transfer_function.browser_test.ts b/src/widget/transfer_function.browser_test.ts
index 23b0d29b9c..da00bf8c84 100644
--- a/src/widget/transfer_function.browser_test.ts
+++ b/src/widget/transfer_function.browser_test.ts
@@ -24,7 +24,6 @@ import {
   defaultDataTypeRange,
 } from "#src/util/lerp.js";
 
-import { Uint64 } from "#src/util/uint64.js";
 import { getShaderType } from "#src/webgl/shader_lib.js";
 import { fragmentShaderTest } from "#src/webgl/shader_testing.js";
 import type { TransferFunctionParameters } from "#src/widget/transfer_function.js";
@@ -90,7 +89,7 @@ describe("Create default transfer function", () => {
     it(`Creates two default transfer function points for ${DataType[dataType]} over a custom window`, () => {
       const window =
         dataType === DataType.UINT64
-          ? ([Uint64.ZERO, Uint64.fromNumber(100)] as [Uint64, Uint64])
+          ? ([0n, 100n] as [bigint, bigint])
           : ([0, 100] as [number, number]);
       transferFunction.generateDefaultControlPoints(null, window);
       expect(transferFunction.sortedControlPoints.controlPoints.length).toBe(2);
@@ -106,7 +105,7 @@ describe("Create default transfer function", () => {
     it(`Creates two default transfer function points for ${DataType[dataType]} with a defined range`, () => {
       const range =
         dataType === DataType.UINT64
-          ? ([Uint64.ZERO, Uint64.fromNumber(100)] as [Uint64, Uint64])
+          ? ([0n, 100n] as [bigint, bigint])
           : ([0, 100] as [number, number]);
       transferFunction.generateDefaultControlPoints(range);
       expect(transferFunction.sortedControlPoints.controlPoints.length).toBe(2);
@@ -120,15 +119,13 @@ describe("Create default transfer function", () => {
     it(`Creates a window which bounds the control points for ${DataType[dataType]}`, () => {
       const range =
         dataType === DataType.UINT64
-          ? ([Uint64.ZERO, Uint64.fromNumber(100)] as [Uint64, Uint64])
+          ? ([0n, 100n] as [bigint, bigint])
           : ([0, 100] as [number, number]);
       const pointInputValues = [0, 20, 40, 60, 80, 100];
       transferFunction.sortedControlPoints.clear();
       for (const inputValue of pointInputValues) {
         const valueToAdd =
-          dataType === DataType.UINT64
-            ? Uint64.fromNumber(inputValue)
-            : inputValue;
+          dataType === DataType.UINT64 ? BigInt(inputValue) : inputValue;
         transferFunction.addPoint(
           new ControlPoint(valueToAdd, vec4.fromValues(0, 0, 0, 0)),
         );
@@ -136,7 +133,7 @@ describe("Create default transfer function", () => {
       transferFunction.generateDefaultWindow();
       const window = transferFunction.trackable.value.window;
       expect(
-        dataTypeIntervalEqual(dataType, window, range),
+        dataTypeIntervalEqual(window, range),
         `Got ${window} expected ${range}`,
       ).toBeTruthy();
     });
@@ -394,14 +391,13 @@ val5 = uTransferFunctionEnd_doTransferFunction;
             expect(size).toBe(usedSize - 1);
             expect(color).toEqual(vec4.fromValues(1, 1, 1, 1));
           }
-          let position: number | Uint64;
+          let position: number | bigint;
           if (dataType !== DataType.UINT64) {
             const minValueNumber = minValue as number;
             const maxValueNumber = maxValue as number;
             position = (maxValueNumber + minValueNumber) / 2;
           } else {
-            const value = (maxValue as Uint64).toNumber() / 2;
-            position = Uint64.fromNumber(value);
+            position = (maxValue as bigint) / 2n;
           }
           const { color, size } = testShader(position);
           expect(size).toBe(usedSize - 1);
diff --git a/src/widget/transfer_function.ts b/src/widget/transfer_function.ts
index 507fab64d6..f3f25033ff 100644
--- a/src/widget/transfer_function.ts
+++ b/src/widget/transfer_function.ts
@@ -48,7 +48,6 @@ import {
 } from "#src/util/lerp.js";
 import { MouseEventBinder } from "#src/util/mouse_bindings.js";
 import { startRelativeMouseDrag } from "#src/util/mouse_drag.js";
-import { Uint64 } from "#src/util/uint64.js";
 import { getWheelZoomAmount } from "#src/util/wheel_zoom.js";
 import type { WatchableVisibilityPriority } from "#src/visibility_priority/frontend.js";
 import { GLBuffer, getMemoizedBuffer } from "#src/webgl/buffer.js";
@@ -155,7 +154,7 @@ interface CanvasPosition {
  */
 export class ControlPoint {
   constructor(
-    public inputValue: number | Uint64,
+    public inputValue: number | bigint,
     public outputColor: vec4 = kZeroVec4,
   ) {}
 
@@ -258,7 +257,7 @@ export class SortedControlPoints {
     }
     this.controlPoints[index].outputColor = outputColor;
   }
-  findNearestControlPointIndex(inputValue: number | Uint64) {
+  findNearestControlPointIndex(inputValue: number | bigint) {
     const controlPoint = new ControlPoint(inputValue);
     const valueToFind = controlPoint.normalizedInput(this.range);
     return this.findNearestControlPointIndexByNormalizedInput(valueToFind);
@@ -753,7 +752,7 @@ class TransferFunctionPanel extends IndirectRenderedPanel {
   updateTransferFunctionPointsAndLines() {
     // Normalize position to [-1, 1] for shader (x axis)
     const window = this.parent.trackable.value.window;
-    function normalizeInput(input: number | Uint64) {
+    function normalizeInput(input: number | bigint) {
       const lerpedInput = computeInvlerp(window, input);
       return lerpedInput * 2 - 1;
     }
@@ -1538,12 +1537,7 @@ class TransferFunctionController extends RefCounted {
     function calculateControlPointGrabDistance() {
       let windowSize = 0.0;
       if (dataType == DataType.UINT64) {
-        const tempUint = new Uint64();
-        windowSize = Uint64.subtract(
-          tempUint,
-          window[1] as Uint64,
-          window[0] as Uint64,
-        ).toNumber();
+        windowSize = Number((window[1] as bigint) - (window[0] as bigint));
       } else if (dataType == DataType.FLOAT32) {
         // Floating point data can have very small windows with many points
         windowSize = 1.0 / CONTROL_POINT_X_GRAB_DISTANCE;
@@ -1655,11 +1649,7 @@ class TransferFunctionWidget extends Tab {
     // If no points and no window, set the default control points for the transfer function
     const currentWindow = this.trackable.value.window;
     const defaultWindow = defaultDataTypeRange[this.dataType];
-    const windowUnset = dataTypeIntervalEqual(
-      this.dataType,
-      currentWindow,
-      defaultWindow,
-    );
+    const windowUnset = dataTypeIntervalEqual(currentWindow, defaultWindow);
     if (this.trackable.value.sortedControlPoints.length === 0 && windowUnset) {
       this.autoRangeFinder.autoComputeRange(0, 1);
     }
diff --git a/testdata/codec/npy/generate_npy_examples.py b/testdata/codec/npy/generate_npy_examples.py
index cf2949d0c0..b690d0cac8 100755
--- a/testdata/codec/npy/generate_npy_examples.py
+++ b/testdata/codec/npy/generate_npy_examples.py
@@ -1,4 +1,10 @@
-#!/usr/bin/env python3
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "numpy",
+# ]
+# ///
 
 # @license
 # Copyright 2016 Google Inc.
@@ -34,18 +40,13 @@ def write_array(array):
         new_array = np.array(array, dtype=dtype.newbyteorder(byte_order))
         name = f"npy_test.{dtype.name}{byte_order_name}"
         np.save(name, new_array)
-    array_for_json = array
-    if dtype == np.uint64:
-        array_for_json = np.asarray(array, dtype=np.dtype("<u8")).view("<u4")
-    if dtype == np.float32:
-        array_for_json = np.asarray(array_for_json, dtype=float)
-    else:
-        array_for_json = np.asarray(array_for_json, dtype=int)
     json_type = float if dtype.kind == "f" else int
+    if dtype == np.uint64:
+        json_type = str
     json_obj = dict(
         dataType=dtype.name,
         shape=array.shape,
-        data=list(json_type(x) for x in array_for_json.ravel()),
+        data=list(json_type(x) for x in array.ravel()),
     )
     with open("npy_test.%s.json" % dtype.name, "w") as f:
         f.write(json.dumps(json_obj))
@@ -58,7 +59,7 @@ def write_array(array):
 def write_int_array(dtype):
     dtype = np.dtype(dtype)
     info = np.iinfo(dtype)
-    write_array(gen.randint(low=info.min, high=info.max + 1, size=shape, dtype=dtype))
+    write_array(gen.integers(low=info.min, high=info.max + 1, size=shape, dtype=dtype))
 
 
 write_int_array(np.uint8)
diff --git a/testdata/codec/npy/npy_test.float32-be.npy b/testdata/codec/npy/npy_test.float32-be.npy
index 982e15e0ed..11be3f9d6a 100644
Binary files a/testdata/codec/npy/npy_test.float32-be.npy and b/testdata/codec/npy/npy_test.float32-be.npy differ
diff --git a/testdata/codec/npy/npy_test.float32-le.npy b/testdata/codec/npy/npy_test.float32-le.npy
index a5e747f326..072a5f0e49 100644
Binary files a/testdata/codec/npy/npy_test.float32-le.npy and b/testdata/codec/npy/npy_test.float32-le.npy differ
diff --git a/testdata/codec/npy/npy_test.float32.json b/testdata/codec/npy/npy_test.float32.json
index 0d5c053701..c8f9a62e00 100644
--- a/testdata/codec/npy/npy_test.float32.json
+++ b/testdata/codec/npy/npy_test.float32.json
@@ -1 +1 @@
-{"dataType": "float32", "shape": [3, 4, 5], "data": [0.29588431119918823, -0.42527997493743896, 1.727639079093933, -0.8683525919914246, -0.8209775686264038, -1.09974205493927, 0.08672983199357986, 0.4562869966030121, 0.43103331327438354, 2.07257342338562, -0.5377851128578186, -1.3784301280975342, -0.4924042522907257, 2.327738046646118, 1.8044040203094482, -0.24942132830619812, -0.8208638429641724, -1.493340015411377, 0.5241759419441223, 0.3451131582260132, 0.7243746519088745, -2.0403809547424316, -1.0797780752182007, -0.69342440366745, -2.338046073913574, 1.6622623205184937, -0.27535274624824524, -0.7465704679489136, 1.225103497505188, -0.1104324609041214, -1.2734893560409546, 0.031786151230335236, 0.4623583257198334, 0.3535483479499817, -1.0619792938232422, -0.2613546848297119, -1.1713985204696655, -1.85708749294281, -0.14481624960899353, -0.4838681221008301, -0.7797969579696655, 1.213905930519104, -2.122512102127075, -0.13776680827140808, -0.41732263565063477, -0.4065365195274353, 1.0609511137008667, -0.10352249443531036, 0.14181682467460632, 0.5818197727203369, 1.3545405864715576, 0.46157705783843994, -0.6517152786254883, 3.8117195799713954e-05, 0.8897542953491211, -1.1562814712524414, 0.39721739292144775, 0.5768476724624634, 0.060000091791152954, 0.5137938261032104]}
\ No newline at end of file
+{"dataType": "float32", "shape": [3, 4, 5], "data": [0.10927969962358475, -0.0757015272974968, 0.20211438834667206, 0.6941719651222229, -0.7583697438240051, 1.420982003211975, 0.7260937690734863, 0.8437326550483704, 1.16486394405365, 0.7875882387161255, 0.8440786600112915, 0.07559361308813095, -1.4267739057540894, -0.1350450962781906, -0.7695146203041077, -1.4227417707443237, 0.25845280289649963, -0.5685494542121887, -1.0298044681549072, -1.0430010557174683, 0.268417090177536, 0.35867196321487427, 1.3224574327468872, -0.013914668932557106, 1.0418397188186646, 1.4022648334503174, 1.1501656770706177, -2.3653039932250977, 1.2286837100982666, 0.3396199941635132, 0.42377135157585144, 0.3712274134159088, 0.38275715708732605, 0.3194142282009125, -0.3589133024215698, -1.9016352891921997, -0.10891472548246384, -0.8037318587303162, 1.0801633596420288, -0.2887665033340454, 0.08347535878419876, -0.8496059775352478, -0.5106224417686462, -0.011533061973750591, -1.485375165939331, 0.3006851077079773, -0.10607225447893143, -1.1857198476791382, -2.398232936859131, 0.5130521059036255, -0.29758402705192566, -0.5300084352493286, -0.23615463078022003, 1.8164759874343872, -0.049800969660282135, 0.08661926537752151, -1.4870728254318237, 1.647339105606079, 0.9174879789352417, 1.0669348239898682]}
\ No newline at end of file
diff --git a/testdata/codec/npy/npy_test.uint16-be.npy b/testdata/codec/npy/npy_test.uint16-be.npy
index 961d6e7cf4..0700a37823 100644
Binary files a/testdata/codec/npy/npy_test.uint16-be.npy and b/testdata/codec/npy/npy_test.uint16-be.npy differ
diff --git a/testdata/codec/npy/npy_test.uint16-le.npy b/testdata/codec/npy/npy_test.uint16-le.npy
index 587a8caca8..c08a61e8e3 100644
Binary files a/testdata/codec/npy/npy_test.uint16-le.npy and b/testdata/codec/npy/npy_test.uint16-le.npy differ
diff --git a/testdata/codec/npy/npy_test.uint16.json b/testdata/codec/npy/npy_test.uint16.json
index 7134421d27..8f44d20bc6 100644
--- a/testdata/codec/npy/npy_test.uint16.json
+++ b/testdata/codec/npy/npy_test.uint16.json
@@ -1 +1 @@
-{"dataType": "uint16", "shape": [3, 4, 5], "data": [48600, 3716, 39512, 63154, 52620, 17868, 14650, 25129, 17089, 31304, 32230, 51886, 18983, 53226, 43095, 34661, 51374, 31455, 24152, 37227, 35665, 25741, 59045, 60659, 16921, 54793, 27469, 4655, 38984, 22111, 6921, 5710, 38804, 42478, 2163, 1325, 5072, 24133, 37619, 54566, 7877, 62728, 18430, 50997, 1871, 9198, 7599, 57017, 2496, 57022, 47954, 64134, 24675, 31038, 42968, 52373, 31921, 52488, 33523, 30243]}
\ No newline at end of file
+{"dataType": "uint16", "shape": [3, 4, 5], "data": [18783, 47808, 32703, 41436, 487, 35627, 49133, 36694, 59399, 61280, 14156, 18176, 51021, 53467, 37040, 43966, 30824, 179, 62960, 25830, 55487, 56190, 38175, 36327, 4211, 2201, 54137, 50127, 45831, 47818, 10150, 55481, 50249, 11511, 32526, 5851, 19258, 56569, 31022, 1448, 13273, 35485, 4664, 5269, 60192, 19641, 55025, 31526, 15055, 27701, 41740, 26426, 62781, 1855, 51816, 350, 1888, 8145, 60328, 542]}
\ No newline at end of file
diff --git a/testdata/codec/npy/npy_test.uint32-be.npy b/testdata/codec/npy/npy_test.uint32-be.npy
index d8730ad167..b8ef771cf6 100644
Binary files a/testdata/codec/npy/npy_test.uint32-be.npy and b/testdata/codec/npy/npy_test.uint32-be.npy differ
diff --git a/testdata/codec/npy/npy_test.uint32-le.npy b/testdata/codec/npy/npy_test.uint32-le.npy
index b1d64bb499..24d4b675a9 100644
Binary files a/testdata/codec/npy/npy_test.uint32-le.npy and b/testdata/codec/npy/npy_test.uint32-le.npy differ
diff --git a/testdata/codec/npy/npy_test.uint32.json b/testdata/codec/npy/npy_test.uint32.json
index 8cb4531361..3b9a4deb07 100644
--- a/testdata/codec/npy/npy_test.uint32.json
+++ b/testdata/codec/npy/npy_test.uint32.json
@@ -1 +1 @@
-{"dataType": "uint32", "shape": [3, 4, 5], "data": [2235433757, 3352347283, 2915765395, 507984782, 3095093671, 2748439840, 2499755969, 615697673, 2308000441, 4057322111, 3258229280, 2241321503, 454869706, 1780959476, 2034098327, 1136257699, 800291326, 3325308363, 3165039474, 1959150775, 930076700, 2441405218, 580757632, 80701568, 1392175012, 2652724277, 642848645, 2628931110, 954863080, 2649711348, 1659957521, 4053367119, 3876630916, 2928395881, 1932520490, 1544074682, 2633087519, 1877037944, 3875557633, 2996303169, 426405863, 258666409, 4165298233, 2863741219, 2805215078, 2880367735, 734051083, 903586222, 1538251858, 553734235, 3224172416, 1354754446, 2610612835, 1562125877, 1396067212, 2448976505, 165035946, 1883779156, 2724186315, 4245033284]}
\ No newline at end of file
+{"dataType": "uint32", "shape": [3, 4, 5], "data": [2880309929, 2257511099, 2779657786, 1105094193, 2643058928, 3281590885, 1647882547, 1979643162, 4282984061, 3457402175, 4212655702, 1630040365, 2944380403, 4080649790, 2793701318, 3609109948, 2956856192, 3023661487, 1670404796, 3758767034, 580235070, 2486371349, 3098768825, 3631311419, 2256379633, 1612402200, 1332478709, 1816595736, 2086646977, 3087315779, 3820321158, 313304722, 4011686354, 2282102940, 1536718668, 2889393617, 2454701931, 1093525229, 1382418508, 3090273955, 2552499193, 2166461506, 1451317662, 3267007164, 1681990799, 1409501674, 3823699226, 1133558435, 975634435, 3067347644, 2676568405, 208505583, 360843153, 1619799228, 3576179383, 1721626191, 3380561489, 1359211872, 1028083929, 3400277764]}
\ No newline at end of file
diff --git a/testdata/codec/npy/npy_test.uint64-be.npy b/testdata/codec/npy/npy_test.uint64-be.npy
index a14de10ed8..b4eabce61d 100644
Binary files a/testdata/codec/npy/npy_test.uint64-be.npy and b/testdata/codec/npy/npy_test.uint64-be.npy differ
diff --git a/testdata/codec/npy/npy_test.uint64-le.npy b/testdata/codec/npy/npy_test.uint64-le.npy
index 7538fb22a8..eaa89581da 100644
Binary files a/testdata/codec/npy/npy_test.uint64-le.npy and b/testdata/codec/npy/npy_test.uint64-le.npy differ
diff --git a/testdata/codec/npy/npy_test.uint64.json b/testdata/codec/npy/npy_test.uint64.json
index 357359fb45..bd04d6fc25 100644
--- a/testdata/codec/npy/npy_test.uint64.json
+++ b/testdata/codec/npy/npy_test.uint64.json
@@ -1 +1 @@
-{"dataType": "uint64", "shape": [3, 4, 5], "data": [438279108, 4118655750, 897118847, 2803713071, 692819075, 2727557108, 2805078884, 4274779084, 1087879144, 2499028148, 2002789519, 1779699534, 1049799907, 2038810260, 682769175, 2677955514, 474057613, 1451731663, 2818914133, 2898039157, 593491249, 1362371120, 844314793, 3342968389, 1583662528, 4078376611, 3526139077, 2845531231, 417046784, 58289758, 3598945970, 2675103601, 412739490, 2893346084, 4193861469, 4174471984, 2012841570, 3771812227, 4195156941, 2188820010, 2597791719, 239292784, 3175112905, 1937714069, 168310272, 85846399, 1214646642, 1897133962, 516240314, 4207292971, 1271912471, 1543802239, 509931650, 2065422011, 1365727330, 2957777273, 1779245987, 3781615166, 275511419, 3943791326, 2974145106, 931243971, 2433534691, 2427467694, 1139839185, 3715587220, 2247333275, 2186005042, 403471401, 3937295118, 2473671361, 3956341818, 3991296778, 356965412, 1368243243, 1192792150, 2866505739, 40186728, 566067507, 3617831682, 3076601888, 2779591760, 1242989696, 3613725878, 786800915, 1137007398, 2519053866, 1708627118, 86361272, 2374350195, 3560270312, 708413884, 20166942, 1588313677, 2911199869, 628962584, 1159675395, 2446492418, 3157634274, 3022528606, 4132568333, 1238996843, 1068386600, 1860958064, 2474576915, 3247453512, 2542800712, 1701229151, 2457803202, 3848455578, 958128308, 2744145144, 4092025836, 3829197123, 1920388878, 2920816445, 3635297540, 1929289568, 3004240621, 4202930115]}
\ No newline at end of file
+{"dataType": "uint64", "shape": [3, 4, 5], "data": ["1080389548951534700", "6200265394693335470", "2772166865342604472", "8307295042895848470", "14689590013673228975", "4254597801902691692", "959623627116559752", "7462664253736073131", "3661919327355147708", "1674098206445630176", "10705243001984662299", "5509971117917422114", "12396117532504645908", "3680410333634169582", "17378919437999810788", "6735093832321390100", "1946044423216464364", "11604997066137502855", "17102982757217513103", "8123524668950463668", "17609086532309083952", "9221450138614817331", "7844083615406347888", "11440918820399615665", "18356290560718802792", "17504921111942386499", "8486334947188954216", "13977630086669507101", "9175829160114866882", "9764085954252175390", "14495187717848137682", "7649050331730722637", "13548830475130767701", "13118270670118174124", "17193466500378917481", "2120132871850371088", "13447955290572086403", "17107951859171531685", "17855086707780737239", "271283443966091747", "15931347716555558556", "18099853790497043721", "17657411208032999235", "2744211661031086175", "17941834807307746912", "16416413438470932068", "15170119529603977013", "8854214388954281865", "4286523778246914958", "14792085813294732880", "17036124501877752041", "4909237023242558809", "9941585089922745854", "8167348124004078731", "17174238156096344565", "747290721537017297", "13503130951646337559", "11333186052202100708", "523248630806453912", "13267263082086403355"]}
\ No newline at end of file
diff --git a/testdata/codec/npy/npy_test.uint8.json b/testdata/codec/npy/npy_test.uint8.json
index 7079fe5b11..4ec3ec3a32 100644
--- a/testdata/codec/npy/npy_test.uint8.json
+++ b/testdata/codec/npy/npy_test.uint8.json
@@ -1 +1 @@
-{"dataType": "uint8", "shape": [3, 4, 5], "data": [172, 10, 127, 140, 47, 170, 196, 151, 117, 166, 22, 183, 192, 204, 33, 216, 67, 179, 78, 154, 251, 82, 162, 219, 195, 118, 125, 139, 103, 125, 229, 216, 9, 164, 116, 108, 211, 222, 161, 159, 21, 81, 89, 165, 242, 214, 102, 98, 36, 183, 5, 112, 87, 58, 43, 76, 70, 60, 75, 228]}
\ No newline at end of file
+{"dataType": "uint8", "shape": [3, 4, 5], "data": [95, 130, 194, 217, 207, 235, 15, 163, 33, 215, 217, 130, 248, 189, 16, 69, 184, 232, 205, 78, 169, 61, 125, 10, 29, 240, 66, 19, 182, 39, 59, 4, 59, 81, 222, 44, 120, 122, 50, 208, 78, 28, 64, 166, 121, 89, 170, 233, 127, 178, 237, 128, 113, 123, 76, 155, 69, 154, 130, 248]}
\ No newline at end of file
diff --git a/testdata/codec/npy/npy_test.uint8.npy b/testdata/codec/npy/npy_test.uint8.npy
index 7437a57999..be0ac32b2a 100644
Binary files a/testdata/codec/npy/npy_test.uint8.npy and b/testdata/codec/npy/npy_test.uint8.npy differ