diff --git a/.changeset/add-tkey-generic-parameter.md b/.changeset/add-tkey-generic-parameter.md
new file mode 100644
index 000000000..40b1dba2f
--- /dev/null
+++ b/.changeset/add-tkey-generic-parameter.md
@@ -0,0 +1,11 @@
+---
+'@tanstack/virtual-core': minor
+'@tanstack/react-virtual': minor
+'@tanstack/vue-virtual': minor
+'@tanstack/solid-virtual': minor
+'@tanstack/svelte-virtual': minor
+'@tanstack/angular-virtual': minor
+'@tanstack/lit-virtual': minor
+---
+
+Add `TKey` generic parameter to `VirtualItem`, `VirtualizerOptions`, and `Virtualizer` to allow narrowing the key type. This fixes a TypeScript error when using `virtualItem.key` as a React component key, since `bigint` in the default `Key` type is not assignable to React's `Key` type.
diff --git a/packages/angular-virtual/src/index.ts b/packages/angular-virtual/src/index.ts
index 55532654a..f0966d78a 100644
--- a/packages/angular-virtual/src/index.ts
+++ b/packages/angular-virtual/src/index.ts
@@ -18,7 +18,11 @@ import {
 } from '@tanstack/virtual-core'
 import { proxyVirtualizer } from './proxy'
 import type { ElementRef, Signal } from '@angular/core'
-import type { PartialKeys, VirtualizerOptions } from '@tanstack/virtual-core'
+import type {
+  Key,
+  PartialKeys,
+  VirtualizerOptions,
+} from '@tanstack/virtual-core'
 import type { AngularVirtualizer } from './types'
 
 export * from '@tanstack/virtual-core'
@@ -27,10 +31,11 @@ export * from './types'
 function createVirtualizerBase<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
-  options: Signal<VirtualizerOptions<TScrollElement, TItemElement>>,
-): AngularVirtualizer<TScrollElement, TItemElement> {
-  let virtualizer: Virtualizer<TScrollElement, TItemElement>
+  options: Signal<VirtualizerOptions<TScrollElement, TItemElement, TKey>>,
+): AngularVirtualizer<TScrollElement, TItemElement, TKey> {
+  let virtualizer: Virtualizer<TScrollElement, TItemElement, TKey>
   function lazyInit() {
     virtualizer ??= new Virtualizer(options())
     return virtualizer
@@ -81,14 +86,15 @@ function createVirtualizerBase<
 export function injectVirtualizer<
   TScrollElement extends Element,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
   options: () => PartialKeys<
-    Omit<VirtualizerOptions<TScrollElement, TItemElement>, 'getScrollElement'>,
+    Omit<VirtualizerOptions<TScrollElement, TItemElement, TKey>, 'getScrollElement'>,
     'observeElementRect' | 'observeElementOffset' | 'scrollToFn'
   > & {
     scrollElement: ElementRef<TScrollElement> | TScrollElement | undefined
   },
-): AngularVirtualizer<TScrollElement, TItemElement> {
+): AngularVirtualizer<TScrollElement, TItemElement, TKey> {
   const resolvedOptions = computed(() => {
     return {
       observeElementRect: observeElementRect,
@@ -105,7 +111,7 @@ export function injectVirtualizer<
       ...options(),
     }
   })
-  return createVirtualizerBase<TScrollElement, TItemElement>(resolvedOptions)
+  return createVirtualizerBase<TScrollElement, TItemElement, TKey>(resolvedOptions)
 }
 
 function isElementRef<T extends Element>(
@@ -114,15 +120,18 @@ function isElementRef<T extends Element>(
   return elementOrRef != null && 'nativeElement' in elementOrRef
 }
 
-export function injectWindowVirtualizer<TItemElement extends Element>(
+export function injectWindowVirtualizer<
+  TItemElement extends Element,
+  TKey extends Key = Key,
+>(
   options: () => PartialKeys<
-    VirtualizerOptions<Window, TItemElement>,
+    VirtualizerOptions<Window, TItemElement, TKey>,
     | 'getScrollElement'
     | 'observeElementRect'
     | 'observeElementOffset'
     | 'scrollToFn'
   >,
-): AngularVirtualizer<Window, TItemElement> {
+): AngularVirtualizer<Window, TItemElement, TKey> {
   const resolvedOptions = computed(() => {
     return {
       getScrollElement: () => (typeof document !== 'undefined' ? window : null),
@@ -134,5 +143,5 @@ export function injectWindowVirtualizer<TItemElement extends Element>(
       ...options(),
     }
   })
-  return createVirtualizerBase<Window, TItemElement>(resolvedOptions)
+  return createVirtualizerBase<Window, TItemElement, TKey>(resolvedOptions)
 }
diff --git a/packages/angular-virtual/src/proxy.ts b/packages/angular-virtual/src/proxy.ts
index 1664b58ea..0e6841676 100644
--- a/packages/angular-virtual/src/proxy.ts
+++ b/packages/angular-virtual/src/proxy.ts
@@ -1,16 +1,17 @@
 import { computed, untracked } from '@angular/core'
 import type { Signal, WritableSignal } from '@angular/core'
-import type { Virtualizer } from '@tanstack/virtual-core'
+import type { Key, Virtualizer } from '@tanstack/virtual-core'
 import type { AngularVirtualizer } from './types'
 
 export function proxyVirtualizer<
-  V extends Virtualizer<any, any>,
-  S extends Element | Window = V extends Virtualizer<infer U, any> ? U : never,
-  I extends Element = V extends Virtualizer<any, infer U> ? U : never,
+  V extends Virtualizer<any, any, any>,
+  S extends Element | Window = V extends Virtualizer<infer U, any, any> ? U : never,
+  I extends Element = V extends Virtualizer<any, infer U, any> ? U : never,
+  K extends Key = V extends Virtualizer<any, any, infer U> ? U : Key,
 >(
   virtualizerSignal: WritableSignal<V>,
   lazyInit: () => V,
-): AngularVirtualizer<S, I> {
+): AngularVirtualizer<S, I, K> {
   return new Proxy(virtualizerSignal, {
     apply() {
       return virtualizerSignal()
@@ -86,10 +87,10 @@ export function proxyVirtualizer<
         configurable: true,
       }
     },
-  }) as unknown as AngularVirtualizer<S, I>
+  }) as unknown as AngularVirtualizer<S, I, K>
 }
 
-function toComputed<V extends Virtualizer<any, any>>(
+function toComputed<V extends Virtualizer<any, any, any>>(
   signal: Signal<V>,
   fn: Function,
 ) {
diff --git a/packages/angular-virtual/src/types.ts b/packages/angular-virtual/src/types.ts
index 08c536cf7..a1903ed75 100644
--- a/packages/angular-virtual/src/types.ts
+++ b/packages/angular-virtual/src/types.ts
@@ -1,11 +1,12 @@
 import type { Signal } from '@angular/core'
-import type { Virtualizer } from '@tanstack/virtual-core'
+import type { Key, Virtualizer } from '@tanstack/virtual-core'
 
 export type AngularVirtualizer<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 > = Omit<
-  Virtualizer<TScrollElement, TItemElement>,
+  Virtualizer<TScrollElement, TItemElement, TKey>,
   | 'getTotalSize'
   | 'getVirtualItems'
   | 'isScrolling'
@@ -17,22 +18,22 @@ export type AngularVirtualizer<
   | 'scrollRect'
 > & {
   getTotalSize: Signal<
-    ReturnType<Virtualizer<TScrollElement, TItemElement>['getTotalSize']>
+    ReturnType<Virtualizer<TScrollElement, TItemElement, TKey>['getTotalSize']>
   >
   getVirtualItems: Signal<
-    ReturnType<Virtualizer<TScrollElement, TItemElement>['getVirtualItems']>
+    ReturnType<Virtualizer<TScrollElement, TItemElement, TKey>['getVirtualItems']>
   >
-  isScrolling: Signal<Virtualizer<TScrollElement, TItemElement>['isScrolling']>
-  options: Signal<Virtualizer<TScrollElement, TItemElement>['options']>
-  range: Signal<Virtualizer<TScrollElement, TItemElement>['range']>
+  isScrolling: Signal<Virtualizer<TScrollElement, TItemElement, TKey>['isScrolling']>
+  options: Signal<Virtualizer<TScrollElement, TItemElement, TKey>['options']>
+  range: Signal<Virtualizer<TScrollElement, TItemElement, TKey>['range']>
   scrollDirection: Signal<
-    Virtualizer<TScrollElement, TItemElement>['scrollDirection']
+    Virtualizer<TScrollElement, TItemElement, TKey>['scrollDirection']
   >
   scrollElement: Signal<
-    Virtualizer<TScrollElement, TItemElement>['scrollElement']
+    Virtualizer<TScrollElement, TItemElement, TKey>['scrollElement']
   >
   scrollOffset: Signal<
-    Virtualizer<TScrollElement, TItemElement>['scrollOffset']
+    Virtualizer<TScrollElement, TItemElement, TKey>['scrollOffset']
   >
-  scrollRect: Signal<Virtualizer<TScrollElement, TItemElement>['scrollRect']>
+  scrollRect: Signal<Virtualizer<TScrollElement, TItemElement, TKey>['scrollRect']>
 }
diff --git a/packages/lit-virtual/src/index.ts b/packages/lit-virtual/src/index.ts
index 963454fdb..699d056c8 100644
--- a/packages/lit-virtual/src/index.ts
+++ b/packages/lit-virtual/src/index.ts
@@ -8,23 +8,28 @@ import {
   windowScroll,
 } from '@tanstack/virtual-core'
 import type { ReactiveController, ReactiveControllerHost } from 'lit'
-import type { PartialKeys, VirtualizerOptions } from '@tanstack/virtual-core'
+import type {
+  Key,
+  PartialKeys,
+  VirtualizerOptions,
+} from '@tanstack/virtual-core'
 
 class VirtualizerControllerBase<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 > implements ReactiveController {
   host: ReactiveControllerHost
 
-  private readonly virtualizer: Virtualizer<TScrollElement, TItemElement>
+  private readonly virtualizer: Virtualizer<TScrollElement, TItemElement, TKey>
 
   private cleanup: () => void = () => {}
 
   constructor(
     host: ReactiveControllerHost,
-    options: VirtualizerOptions<TScrollElement, TItemElement>,
+    options: VirtualizerOptions<TScrollElement, TItemElement, TKey>,
   ) {
-    const resolvedOptions: VirtualizerOptions<TScrollElement, TItemElement> = {
+    const resolvedOptions: VirtualizerOptions<TScrollElement, TItemElement, TKey> = {
       ...options,
       onChange: (instance, sync) => {
         this.host.updateComplete.then(() => this.host.requestUpdate())
@@ -55,11 +60,12 @@ class VirtualizerControllerBase<
 export class VirtualizerController<
   TScrollElement extends Element,
   TItemElement extends Element,
-> extends VirtualizerControllerBase<TScrollElement, TItemElement> {
+  TKey extends Key = Key,
+> extends VirtualizerControllerBase<TScrollElement, TItemElement, TKey> {
   constructor(
     host: ReactiveControllerHost,
     options: PartialKeys<
-      VirtualizerOptions<TScrollElement, TItemElement>,
+      VirtualizerOptions<TScrollElement, TItemElement, TKey>,
       'observeElementRect' | 'observeElementOffset' | 'scrollToFn'
     >,
   ) {
@@ -74,11 +80,12 @@ export class VirtualizerController<
 
 export class WindowVirtualizerController<
   TItemElement extends Element,
-> extends VirtualizerControllerBase<Window, TItemElement> {
+  TKey extends Key = Key,
+> extends VirtualizerControllerBase<Window, TItemElement, TKey> {
   constructor(
     host: ReactiveControllerHost,
     options: PartialKeys<
-      VirtualizerOptions<Window, TItemElement>,
+      VirtualizerOptions<Window, TItemElement, TKey>,
       | 'getScrollElement'
       | 'observeElementRect'
       | 'observeElementOffset'
diff --git a/packages/react-virtual/src/index.tsx b/packages/react-virtual/src/index.tsx
index 313c3d4f9..fc60fcd08 100644
--- a/packages/react-virtual/src/index.tsx
+++ b/packages/react-virtual/src/index.tsx
@@ -9,7 +9,11 @@ import {
   observeWindowRect,
   windowScroll,
 } from '@tanstack/virtual-core'
-import type { PartialKeys, VirtualizerOptions } from '@tanstack/virtual-core'
+import type {
+  Key,
+  PartialKeys,
+  VirtualizerOptions,
+} from '@tanstack/virtual-core'
 
 export * from '@tanstack/virtual-core'
 
@@ -19,23 +23,26 @@ const useIsomorphicLayoutEffect =
 export type ReactVirtualizerOptions<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
-> = VirtualizerOptions<TScrollElement, TItemElement> & {
+  TKey extends Key = Key,
+> = VirtualizerOptions<TScrollElement, TItemElement, TKey> & {
   useFlushSync?: boolean
 }
 
 function useVirtualizerBase<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >({
   useFlushSync = true,
   ...options
-}: ReactVirtualizerOptions<TScrollElement, TItemElement>): Virtualizer<
+}: ReactVirtualizerOptions<TScrollElement, TItemElement, TKey>): Virtualizer<
   TScrollElement,
-  TItemElement
+  TItemElement,
+  TKey
 > {
   const rerender = React.useReducer(() => ({}), {})[1]
 
-  const resolvedOptions: VirtualizerOptions<TScrollElement, TItemElement> = {
+  const resolvedOptions: VirtualizerOptions<TScrollElement, TItemElement, TKey> = {
     ...options,
     onChange: (instance, sync) => {
       if (useFlushSync && sync) {
@@ -48,7 +55,8 @@ function useVirtualizerBase<
   }
 
   const [instance] = React.useState(
-    () => new Virtualizer<TScrollElement, TItemElement>(resolvedOptions),
+    () =>
+      new Virtualizer<TScrollElement, TItemElement, TKey>(resolvedOptions),
   )
 
   instance.setOptions(resolvedOptions)
@@ -67,13 +75,14 @@ function useVirtualizerBase<
 export function useVirtualizer<
   TScrollElement extends Element,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
   options: PartialKeys<
-    ReactVirtualizerOptions<TScrollElement, TItemElement>,
+    ReactVirtualizerOptions<TScrollElement, TItemElement, TKey>,
     'observeElementRect' | 'observeElementOffset' | 'scrollToFn'
   >,
-): Virtualizer<TScrollElement, TItemElement> {
-  return useVirtualizerBase<TScrollElement, TItemElement>({
+): Virtualizer<TScrollElement, TItemElement, TKey> {
+  return useVirtualizerBase<TScrollElement, TItemElement, TKey>({
     observeElementRect: observeElementRect,
     observeElementOffset: observeElementOffset,
     scrollToFn: elementScroll,
@@ -81,16 +90,19 @@ export function useVirtualizer<
   })
 }
 
-export function useWindowVirtualizer<TItemElement extends Element>(
+export function useWindowVirtualizer<
+  TItemElement extends Element,
+  TKey extends Key = Key,
+>(
   options: PartialKeys<
-    ReactVirtualizerOptions<Window, TItemElement>,
+    ReactVirtualizerOptions<Window, TItemElement, TKey>,
     | 'getScrollElement'
     | 'observeElementRect'
     | 'observeElementOffset'
     | 'scrollToFn'
   >,
-): Virtualizer<Window, TItemElement> {
-  return useVirtualizerBase<Window, TItemElement>({
+): Virtualizer<Window, TItemElement, TKey> {
+  return useVirtualizerBase<Window, TItemElement, TKey>({
     getScrollElement: () => (typeof document !== 'undefined' ? window : null),
     observeElementRect: observeWindowRect,
     observeElementOffset: observeWindowOffset,
diff --git a/packages/solid-virtual/src/index.tsx b/packages/solid-virtual/src/index.tsx
index 69ac34fd7..6f0d97aec 100644
--- a/packages/solid-virtual/src/index.tsx
+++ b/packages/solid-virtual/src/index.tsx
@@ -16,20 +16,25 @@ import {
   onMount,
 } from 'solid-js'
 import { createStore, reconcile } from 'solid-js/store'
-import type { PartialKeys, VirtualizerOptions } from '@tanstack/virtual-core'
+import type {
+  Key,
+  PartialKeys,
+  VirtualizerOptions,
+} from '@tanstack/virtual-core'
 
 export * from '@tanstack/virtual-core'
 
 function createVirtualizerBase<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
-  options: VirtualizerOptions<TScrollElement, TItemElement>,
-): Virtualizer<TScrollElement, TItemElement> {
-  const resolvedOptions: VirtualizerOptions<TScrollElement, TItemElement> =
+  options: VirtualizerOptions<TScrollElement, TItemElement, TKey>,
+): Virtualizer<TScrollElement, TItemElement, TKey> {
+  const resolvedOptions: VirtualizerOptions<TScrollElement, TItemElement, TKey> =
     mergeProps(options)
 
-  const instance = new Virtualizer<TScrollElement, TItemElement>(
+  const instance = new Virtualizer<TScrollElement, TItemElement, TKey>(
     resolvedOptions,
   )
 
@@ -40,8 +45,8 @@ function createVirtualizerBase<
 
   const handler = {
     get(
-      target: Virtualizer<TScrollElement, TItemElement>,
-      prop: keyof Virtualizer<TScrollElement, TItemElement>,
+      target: Virtualizer<TScrollElement, TItemElement, TKey>,
+      prop: keyof Virtualizer<TScrollElement, TItemElement, TKey>,
     ) {
       switch (prop) {
         case 'getVirtualItems':
@@ -67,7 +72,7 @@ function createVirtualizerBase<
     virtualizer.setOptions(
       mergeProps(resolvedOptions, options, {
         onChange: (
-          instance: Virtualizer<TScrollElement, TItemElement>,
+          instance: Virtualizer<TScrollElement, TItemElement, TKey>,
           sync: boolean,
         ) => {
           instance._willUpdate()
@@ -90,13 +95,14 @@ function createVirtualizerBase<
 export function createVirtualizer<
   TScrollElement extends Element,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
   options: PartialKeys<
-    VirtualizerOptions<TScrollElement, TItemElement>,
+    VirtualizerOptions<TScrollElement, TItemElement, TKey>,
     'observeElementRect' | 'observeElementOffset' | 'scrollToFn'
   >,
-): Virtualizer<TScrollElement, TItemElement> {
-  return createVirtualizerBase<TScrollElement, TItemElement>(
+): Virtualizer<TScrollElement, TItemElement, TKey> {
+  return createVirtualizerBase<TScrollElement, TItemElement, TKey>(
     mergeProps(
       {
         observeElementRect: observeElementRect,
@@ -108,16 +114,19 @@ export function createVirtualizer<
   )
 }
 
-export function createWindowVirtualizer<TItemElement extends Element>(
+export function createWindowVirtualizer<
+  TItemElement extends Element,
+  TKey extends Key = Key,
+>(
   options: PartialKeys<
-    VirtualizerOptions<Window, TItemElement>,
+    VirtualizerOptions<Window, TItemElement, TKey>,
     | 'getScrollElement'
     | 'observeElementRect'
     | 'observeElementOffset'
     | 'scrollToFn'
   >,
-): Virtualizer<Window, TItemElement> {
-  return createVirtualizerBase<Window, TItemElement>(
+): Virtualizer<Window, TItemElement, TKey> {
+  return createVirtualizerBase<Window, TItemElement, TKey>(
     mergeProps(
       {
         getScrollElement: () =>
diff --git a/packages/svelte-virtual/src/index.ts b/packages/svelte-virtual/src/index.ts
index f16aa03ce..2aa8bb655 100644
--- a/packages/svelte-virtual/src/index.ts
+++ b/packages/svelte-virtual/src/index.ts
@@ -8,7 +8,11 @@ import {
   windowScroll,
 } from '@tanstack/virtual-core'
 import { derived, writable } from 'svelte/store'
-import type { PartialKeys, VirtualizerOptions } from '@tanstack/virtual-core'
+import type {
+  Key,
+  PartialKeys,
+  VirtualizerOptions,
+} from '@tanstack/virtual-core'
 import type { Readable, Writable } from 'svelte/store'
 
 export * from '@tanstack/virtual-core'
@@ -16,26 +20,28 @@ export * from '@tanstack/virtual-core'
 export type SvelteVirtualizer<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
-> = Omit<Virtualizer<TScrollElement, TItemElement>, 'setOptions'> & {
+  TKey extends Key = Key,
+> = Omit<Virtualizer<TScrollElement, TItemElement, TKey>, 'setOptions'> & {
   setOptions: (
-    options: Partial<VirtualizerOptions<TScrollElement, TItemElement>>,
+    options: Partial<VirtualizerOptions<TScrollElement, TItemElement, TKey>>,
   ) => void
 }
 
 function createVirtualizerBase<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
-  initialOptions: VirtualizerOptions<TScrollElement, TItemElement>,
-): Readable<SvelteVirtualizer<TScrollElement, TItemElement>> {
+  initialOptions: VirtualizerOptions<TScrollElement, TItemElement, TKey>,
+): Readable<SvelteVirtualizer<TScrollElement, TItemElement, TKey>> {
   const virtualizer = new Virtualizer(initialOptions)
   const originalSetOptions = virtualizer.setOptions
 
   // eslint-disable-next-line prefer-const
-  let virtualizerWritable: Writable<Virtualizer<TScrollElement, TItemElement>>
+  let virtualizerWritable: Writable<Virtualizer<TScrollElement, TItemElement, TKey>>
 
   const setOptions = (
-    options: Partial<VirtualizerOptions<TScrollElement, TItemElement>>,
+    options: Partial<VirtualizerOptions<TScrollElement, TItemElement, TKey>>,
   ) => {
     const resolvedOptions = {
       ...virtualizer.options,
@@ -45,7 +51,7 @@ function createVirtualizerBase<
     originalSetOptions({
       ...resolvedOptions,
       onChange: (
-        instance: Virtualizer<TScrollElement, TItemElement>,
+        instance: Virtualizer<TScrollElement, TItemElement, TKey>,
         sync: boolean,
       ) => {
         virtualizerWritable.set(instance)
@@ -68,13 +74,14 @@ function createVirtualizerBase<
 export function createVirtualizer<
   TScrollElement extends Element,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
   options: PartialKeys<
-    VirtualizerOptions<TScrollElement, TItemElement>,
+    VirtualizerOptions<TScrollElement, TItemElement, TKey>,
     'observeElementRect' | 'observeElementOffset' | 'scrollToFn'
   >,
-): Readable<SvelteVirtualizer<TScrollElement, TItemElement>> {
-  return createVirtualizerBase<TScrollElement, TItemElement>({
+): Readable<SvelteVirtualizer<TScrollElement, TItemElement, TKey>> {
+  return createVirtualizerBase<TScrollElement, TItemElement, TKey>({
     observeElementRect: observeElementRect,
     observeElementOffset: observeElementOffset,
     scrollToFn: elementScroll,
@@ -82,16 +89,19 @@ export function createVirtualizer<
   })
 }
 
-export function createWindowVirtualizer<TItemElement extends Element>(
+export function createWindowVirtualizer<
+  TItemElement extends Element,
+  TKey extends Key = Key,
+>(
   options: PartialKeys<
-    VirtualizerOptions<Window, TItemElement>,
+    VirtualizerOptions<Window, TItemElement, TKey>,
     | 'getScrollElement'
     | 'observeElementRect'
     | 'observeElementOffset'
     | 'scrollToFn'
   >,
-): Readable<SvelteVirtualizer<Window, TItemElement>> {
-  return createVirtualizerBase<Window, TItemElement>({
+): Readable<SvelteVirtualizer<Window, TItemElement, TKey>> {
+  return createVirtualizerBase<Window, TItemElement, TKey>({
     getScrollElement: () => (typeof document !== 'undefined' ? window : null),
     observeElementRect: observeWindowRect,
     observeElementOffset: observeWindowOffset,
diff --git a/packages/virtual-core/src/index.ts b/packages/virtual-core/src/index.ts
index bc966a6ce..7b47e23c8 100644
--- a/packages/virtual-core/src/index.ts
+++ b/packages/virtual-core/src/index.ts
@@ -26,10 +26,10 @@ export interface Range {
   count: number
 }
 
-type Key = number | string | bigint
+export type Key = number | string | bigint
 
-export interface VirtualItem {
-  key: Key
+export interface VirtualItem<TKey extends Key = Key> {
+  key: TKey
   index: number
   start: number
   end: number
@@ -243,7 +243,7 @@ export const observeWindowOffset = (
 export const measureElement = <TItemElement extends Element>(
   element: TItemElement,
   entry: ResizeObserverEntry | undefined,
-  instance: Virtualizer<any, TItemElement>,
+  instance: Virtualizer<any, TItemElement, any>,
 ) => {
   if (entry?.borderBoxSize) {
     const box = entry.borderBoxSize[0]
@@ -295,6 +295,7 @@ export const elementScroll = <T extends Element>(
 export interface VirtualizerOptions<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 > {
   // Required from the user
   count: number
@@ -305,27 +306,27 @@ export interface VirtualizerOptions<
   scrollToFn: (
     offset: number,
     options: { adjustments?: number; behavior?: ScrollBehavior },
-    instance: Virtualizer<TScrollElement, TItemElement>,
+    instance: Virtualizer<TScrollElement, TItemElement, any>,
   ) => void
   observeElementRect: (
-    instance: Virtualizer<TScrollElement, TItemElement>,
+    instance: Virtualizer<TScrollElement, TItemElement, any>,
     cb: (rect: Rect) => void,
   ) => void | (() => void)
   observeElementOffset: (
-    instance: Virtualizer<TScrollElement, TItemElement>,
+    instance: Virtualizer<TScrollElement, TItemElement, any>,
     cb: ObserveOffsetCallBack,
   ) => void | (() => void)
   // Optional
   debug?: boolean
   initialRect?: Rect
   onChange?: (
-    instance: Virtualizer<TScrollElement, TItemElement>,
+    instance: Virtualizer<TScrollElement, TItemElement, TKey>,
     sync: boolean,
   ) => void
   measureElement?: (
     element: TItemElement,
     entry: ResizeObserverEntry | undefined,
-    instance: Virtualizer<TScrollElement, TItemElement>,
+    instance: Virtualizer<TScrollElement, TItemElement, TKey>,
   ) => number
   overscan?: number
   horizontal?: boolean
@@ -334,12 +335,12 @@ export interface VirtualizerOptions<
   scrollPaddingStart?: number
   scrollPaddingEnd?: number
   initialOffset?: number | (() => number)
-  getItemKey?: (index: number) => Key
+  getItemKey?: (index: number) => TKey
   rangeExtractor?: (range: Range) => Array<number>
   scrollMargin?: number
   gap?: number
   indexAttribute?: string
-  initialMeasurementsCache?: Array<VirtualItem>
+  initialMeasurementsCache?: Array<VirtualItem<TKey>>
   lanes?: number
   isScrollingResetDelay?: number
   useScrollendEvent?: boolean
@@ -367,15 +368,16 @@ type ScrollState = {
 export class Virtualizer<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 > {
   private unsubs: Array<void | (() => void)> = []
-  options!: Required<VirtualizerOptions<TScrollElement, TItemElement>>
+  options!: Required<VirtualizerOptions<TScrollElement, TItemElement, TKey>>
   scrollElement: TScrollElement | null = null
   targetWindow: (Window & typeof globalThis) | null = null
   isScrolling = false
   private scrollState: ScrollState | null = null
-  measurementsCache: Array<VirtualItem> = []
-  private itemSizeCache = new Map<Key, number>()
+  measurementsCache: Array<VirtualItem<TKey>> = []
+  private itemSizeCache = new Map<TKey, number>()
   private laneAssignments = new Map<number, number>() // index → lane cache
   private pendingMeasuredCacheIndexes: Array<number> = []
   private prevLanes: number | undefined = undefined
@@ -388,11 +390,11 @@ export class Virtualizer<
   shouldAdjustScrollPositionOnItemSizeChange:
     | undefined
     | ((
-        item: VirtualItem,
+        item: VirtualItem<TKey>,
         delta: number,
-        instance: Virtualizer<TScrollElement, TItemElement>,
+        instance: Virtualizer<TScrollElement, TItemElement, any>,
       ) => boolean)
-  elementsCache = new Map<Key, TItemElement>()
+  elementsCache = new Map<TKey, TItemElement>()
   private now = () => this.targetWindow?.performance?.now?.() ?? Date.now()
   private observer = (() => {
     let _ro: ResizeObserver | null = null
@@ -430,11 +432,11 @@ export class Virtualizer<
   })()
   range: { startIndex: number; endIndex: number } | null = null
 
-  constructor(opts: VirtualizerOptions<TScrollElement, TItemElement>) {
+  constructor(opts: VirtualizerOptions<TScrollElement, TItemElement, TKey>) {
     this.setOptions(opts)
   }
 
-  setOptions = (opts: VirtualizerOptions<TScrollElement, TItemElement>) => {
+  setOptions = (opts: VirtualizerOptions<TScrollElement, TItemElement, TKey>) => {
     Object.entries(opts).forEach(([key, value]) => {
       if (typeof value === 'undefined') delete (opts as any)[key]
     })
@@ -448,7 +450,7 @@ export class Virtualizer<
       scrollPaddingStart: 0,
       scrollPaddingEnd: 0,
       horizontal: false,
-      getItemKey: defaultKeyExtractor,
+      getItemKey: defaultKeyExtractor as (index: number) => TKey,
       rangeExtractor: defaultRangeExtractor,
       onChange: () => {},
       measureElement,
@@ -666,11 +668,11 @@ export class Virtualizer<
   }
 
   private getFurthestMeasurement = (
-    measurements: Array<VirtualItem>,
+    measurements: Array<VirtualItem<TKey>>,
     index: number,
   ) => {
     const furthestMeasurementsFound = new Map<number, true>()
-    const furthestMeasurements = new Map<number, VirtualItem>()
+    const furthestMeasurements = new Map<number, VirtualItem<TKey>>()
     for (let m = index - 1; m >= 0; m--) {
       const measurement = measurements[m]!
 
@@ -1062,7 +1064,7 @@ export class Virtualizer<
   getVirtualItems = memo(
     () => [this.getVirtualIndexes(), this.getMeasurements()],
     (indexes, measurements) => {
-      const virtualItems: Array<VirtualItem> = []
+      const virtualItems: Array<VirtualItem<TKey>> = []
 
       for (let k = 0, len = indexes.length; k < len; k++) {
         const i = indexes[k]!
@@ -1332,7 +1334,7 @@ function calculateRange({
   scrollOffset,
   lanes,
 }: {
-  measurements: Array<VirtualItem>
+  measurements: Array<VirtualItem<any>>
   outerSize: number
   scrollOffset: number
   lanes: number
diff --git a/packages/vue-virtual/src/index.ts b/packages/vue-virtual/src/index.ts
index 57f73311c..28c196de8 100644
--- a/packages/vue-virtual/src/index.ts
+++ b/packages/vue-virtual/src/index.ts
@@ -15,7 +15,11 @@ import {
   unref,
   watch,
 } from 'vue'
-import type { PartialKeys, VirtualizerOptions } from '@tanstack/virtual-core'
+import type {
+  Key,
+  PartialKeys,
+  VirtualizerOptions,
+} from '@tanstack/virtual-core'
 import type { Ref } from 'vue'
 
 export * from '@tanstack/virtual-core'
@@ -25,9 +29,10 @@ type MaybeRef<T> = T | Ref<T>
 function useVirtualizerBase<
   TScrollElement extends Element | Window,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
-  options: MaybeRef<VirtualizerOptions<TScrollElement, TItemElement>>,
-): Ref<Virtualizer<TScrollElement, TItemElement>> {
+  options: MaybeRef<VirtualizerOptions<TScrollElement, TItemElement, TKey>>,
+): Ref<Virtualizer<TScrollElement, TItemElement, TKey>> {
   const virtualizer = new Virtualizer(unref(options))
   const state = shallowRef(virtualizer)
 
@@ -72,15 +77,16 @@ function useVirtualizerBase<
 export function useVirtualizer<
   TScrollElement extends Element,
   TItemElement extends Element,
+  TKey extends Key = Key,
 >(
   options: MaybeRef<
     PartialKeys<
-      VirtualizerOptions<TScrollElement, TItemElement>,
+      VirtualizerOptions<TScrollElement, TItemElement, TKey>,
       'observeElementRect' | 'observeElementOffset' | 'scrollToFn'
     >
   >,
-): Ref<Virtualizer<TScrollElement, TItemElement>> {
-  return useVirtualizerBase<TScrollElement, TItemElement>(
+): Ref<Virtualizer<TScrollElement, TItemElement, TKey>> {
+  return useVirtualizerBase<TScrollElement, TItemElement, TKey>(
     computed(() => ({
       observeElementRect: observeElementRect,
       observeElementOffset: observeElementOffset,
@@ -90,18 +96,21 @@ export function useVirtualizer<
   )
 }
 
-export function useWindowVirtualizer<TItemElement extends Element>(
+export function useWindowVirtualizer<
+  TItemElement extends Element,
+  TKey extends Key = Key,
+>(
   options: MaybeRef<
     PartialKeys<
-      VirtualizerOptions<Window, TItemElement>,
+      VirtualizerOptions<Window, TItemElement, TKey>,
       | 'observeElementRect'
       | 'observeElementOffset'
       | 'scrollToFn'
       | 'getScrollElement'
     >
   >,
-): Ref<Virtualizer<Window, TItemElement>> {
-  return useVirtualizerBase<Window, TItemElement>(
+): Ref<Virtualizer<Window, TItemElement, TKey>> {
+  return useVirtualizerBase<Window, TItemElement, TKey>(
     computed(() => ({
       getScrollElement: () => (typeof document !== 'undefined' ? window : null),
       observeElementRect: observeWindowRect,