@dnd-kit/core

In production, @dnd-kit/core handles drag-and-drop interactions reliably with impressive accessibility out of the box. The sensor system is well-designed, and the collision detection algorithms perform well even with hundreds of draggable items. However, you need to be careful with event listener cleanup—I've tracked down memory leaks in large lists where draggable components weren't properly unmounting their sensors. Memoizing your drag handlers and collision detection functions is essential for performance.

The library's approach to state management through contexts works well but requires understanding of React's render cycle to avoid unnecessary re-renders. The modifiers system is powerful for constraints and transforms, though the documentation assumes you understand the coordinate system internals. Error boundaries are your friend here—sensor activation failures can be silent without proper logging hooks.

Timeout behavior during drag operations is configurable but defaults could be more aggressive for slower devices. The migration from v5 to v6 had breaking changes in collision detection APIs that required careful testing. Resource cleanup is generally good, but watch for leaked RAF callbacks if you implement custom sensors.

In production, @dnd-kit/core handles complex drag-and-drop scenarios well once you understand its patterns. The library is genuinely lightweight and doesn't bloat bundle size. The sensor system is flexible—you can customize touch, mouse, and keyboard interactions independently. Accessibility is baked in properly with keyboard navigation and screen reader support working out of the box.

The performance story requires attention though. By default, every drag operation triggers re-renders across your tree. You'll need to memoize components aggressively and use the collision detection algorithms carefully. With large lists (500+ items), expect to implement virtualization yourself and carefully manage which components subscribe to drag state. The measuring phase can cause jank if you have complex layouts.

Error boundaries are essential—the library doesn't handle malformed data gracefully and will throw during drag if items disappear mid-operation. There's no built-in retry logic for failed operations. Documentation is thorough but scattered; expect to read source code for edge cases. Configuration is verbose but predictable. No breaking changes between minor versions in my experience.

In production, @dnd-kit/core delivers on its performance promise through its sensor-based architecture and virtualization support. The collision detection algorithms are configurable and efficient, but you need to memoize your data structures carefully—re-creating droppable arrays on every render will tank performance fast. The library doesn't warn you about this, so watch your React DevTools profiler.

Error handling is minimal. When sensors fail (touch events on iOS Safari can be finicky), you get silent failures unless you implement custom logging in your onDragEnd handlers. The accessibility features work well out of the box, but there's no built-in retry logic if drag operations fail. Resource cleanup is generally good—event listeners are properly removed—but complex nested droppable scenarios can leak references if you're not careful with your context structure.

Configuration is extremely flexible through modifiers and sensors, though this means more setup code compared to simpler libraries. No breaking changes between 6.x versions have bitten me. Timeout behavior is predictable, and it handles rapid successive drags without choking, though you'll want to debounce any heavy operations in your drag handlers.