Open-source alternatives to DeepCopy

Fory is a cross-language serialization framework and binary data serializer designed to convert complex object graphs into a compact binary format for high-performance data exchange. It includes an IDL-based schema compiler to transform interface definition language files into type-safe native data models and a schema evolution manager to maintain forward and backward compatibility. The project features a zero-copy data access layer that allows reading specific fields from binary rows without deserializing the entire object. It supports dual-mode serialization, enabling a toggle between a por

Immutable.js is a library of persistent data structures and a functional state management toolkit. It provides a collection of immutable objects and arrays that prevent direct mutation to ensure predictable state management in JavaScript applications. The library utilizes structural sharing to efficiently create new versions of data without full copying and implements lazy sequence processing to chain data transformations that execute only when values are requested. It also supports batch mutation processing, allowing multiple changes to be applied to a temporary mutable copy before returning

Object-enumerator is a data structure crawler and enumeration library designed to discover and list all objects stored within deep or circular data references. It functions as a traversal tool that recursively walks through nested arrays and object graphs to identify every individual referenced object. The library flattens complex hierarchical data structures into a linear collection of unique objects. This process enables data structure analysis and memory reference mapping by tracing all objects connected to a root element to understand the overall composition of a data set.

Radash is a TypeScript functional utility library designed for data transformation, validation, and workflow management. It provides a collection of typed helper functions to manipulate arrays, objects, and strings. The project features an asynchronous workflow toolkit for managing promises, retries, and concurrency limits, alongside a suite of boolean validators for verifying primitive types, objects, and promises. It also implements functional programming patterns such as function composition, partial application, and error-first response patterns. The library covers a broad surface of cap

pypdf is a Python library for parsing, manipulating, and generating PDF documents. It provides high-level operations for document processing, such as merging multiple files into one or splitting a single document into smaller files. The project includes specialized tools for managing interactive elements, including the creation and modification of annotations, hyperlinks, and form fields. It also supports advanced metadata management, allowing for the extraction and modification of standard document properties and XML-based XMP metadata. Beyond basic structural changes, the library covers pa

Just is a collection of JavaScript utility libraries designed for data manipulation, functional programming, performance optimization, statistical analysis, and string processing. It provides a set of tools for deep cloning, filtering, and transforming complex objects and arrays. The project is structured as a series of zero-dependency modules, allowing utilities to be used independently to minimize bundle size. It implements functional programming patterns including currying, piping, and partial application, and provides execution control through memoization, debouncing, and throttling. The

This is a persistent data structure library for JavaScript that provides collections which prevent the direct mutation of objects and arrays. It serves as an immutable state management tool and functional programming utility, ensuring that data remains unchanged after creation to simplify change detection and state tracking. The library enables the maintenance of application state by producing new versions of data structures during updates. It focuses on efficient data comparison by checking actual content instead of memory references and supports a functional programming workflow to prevent

Mapperly is a C# source generator used for high-performance object-to-object mapping in .NET. It functions as a compile-time mapping library that produces the necessary transformation code during the build process, eliminating the need for runtime reflection when converting between domain models and data transfer objects. The tool distinguishes itself by providing type-safe diagnostic validation and strict mapping enforcement, emitting warnings for unmapped properties at compile time. It includes specialized capabilities for circular reference handling and deep cloning to maintain object iden

Sugar is a JavaScript utility library designed to extend native objects and prototypes with additional methods for data manipulation and transformation. It functions as a toolkit for object utilities, date manipulation, string inflection, and the polyfilling of missing or broken standard language features. The library provides the ability to map utility methods directly onto built-in prototypes or wrap values in temporary objects to enable method chaining without modifying global prototypes. It also includes a polyfill system to ensure consistent behavior across different execution environmen

Lancet is a comprehensive extension of the Go standard library, providing a collection of reusable functions and data structures designed to reduce boilerplate code in applications. It serves as a general-purpose toolkit across multiple domains, including concurrency, security, networking, and functional logic. The project distinguishes itself through specialized toolkits for Go concurrency, such as keyed locking and channel-based stream processing, and a dedicated functional programming kit that supports currying and function composition. It also includes a dedicated cryptography library imp

This project is a Redux state logger and console debugging tool. It functions as middleware for the Redux dispatch pipeline, acting as a state transition tracker that records actions and state changes directly to the browser console. The tool allows for the interception of actions to log timing, payloads, and state transitions. It provides capabilities to filter specific actions using predicate functions to reduce noise and transform complex state or immutable data into readable formats for easier inspection. The utility includes options for customizing console output through timestamps, col

Redux DevTools is a state management debugger and visualizer for Redux applications. It provides a set of interfaces for inspecting state trees, monitoring real-time state changes, and dispatching actions. The project features a state time travel debugger that allows for rewinding and replaying sequences of dispatched actions to reproduce specific application states. It includes a remote state monitor to track state changes from sources in environments where local browser access is unavailable. The toolset covers action history replay, state change inspection, and hot-reload development work

This project is a technical interview preparation resource focused on JavaScript. It provides a collection of common technical questions, detailed answers, and conceptual quizzes designed to help users master core language fundamentals and browser APIs. The resource utilizes an interactive infrastructure that includes a coding workspace with in-browser runtime execution and an automated test suite to validate code correctness. It organizes content through curated learning paths and modular concept mapping to decompose complex language fundamentals into searchable study modules. The curriculu

Underscore is a JavaScript utility library providing a suite of functional programming and data manipulation helpers. It serves as a framework for transforming data collections, composing functions, managing objects, and performing precise data type validation without modifying core language prototypes. The project includes a functional programming toolkit designed to control function execution timing and behavior through techniques such as debouncing, throttling, and partial application. It also provides a dedicated object manipulation utility for cloning, merging, picking, and omitting prop

This project is a comprehensive frontend interview preparation resource built around a question bank of over 1000 curated questions. It covers HTML, CSS, JavaScript, Vue, React, Node, TypeScript, Webpack, algorithms, and network security, with each question accompanied by a detailed answer explanation. The content is organized into a hierarchical category tree for browsable exploration, and a daily question rotation algorithm presents one question per day for systematic review. A client-side search index enables instant filtering of questions by title or tag, and the entire question bank is p

Mapster is a .NET object-to-object mapper and high-performance mapping engine used for transforming data between different object models. It functions as a type-safe data transfer tool and a LINQ query projection tool to move data between internal logic and external data structures. The engine utilizes compiled mapping expressions and machine code to reduce overhead during object conversion. It specifically allows for projecting queryable data sources directly into destination types to optimize database retrieval. The toolset covers data transfer object generation, immutable data transformat

Metalsmith is a Node.js static site generator and static content processor that transforms source files into websites, eBooks, or technical documentation. It functions as a file-to-object transformer, converting directory trees into plain JavaScript objects that can be programmatically manipulated in memory. The project is built around a pluggable build pipeline where files are passed through a sequence of custom functions to transform content and metadata incrementally. This architecture allows users to extend functionality by writing their own plugins or using third-party modules to define

MobX State Tree is a structured, tree-based state management library for JavaScript applications that combines typed model definitions with reactive snapshots and patch-based change tracking. It provides a reactive state container with runtime and compile-time type safety, where application state is defined as a tree of typed models with collocated actions, computed views, and lifecycle hooks for predictable state mutations. The library is built around an action-centric mutation model that encapsulates all state changes within named functions that directly modify the tree, supported by genera

Immer is an immutable state management library for JavaScript that enables the creation of new versions of state trees. It functions as a state container that uses a proxy-based handler to ensure data immutability. The library utilizes a copy-on-write mechanism and a draft-based mutation model. This allows users to write mutating code on a temporary proxy, which the system then uses to produce a new immutable result while keeping the original state unchanged. The project covers immutable state management and complex object cloning to facilitate predictable state transitions. These capabiliti

This project is a state management inspector and debugging tool for Redux. It provides a browser-based interface for inspecting and modifying application state and actions in real time, serving as an action logger and time travel debugger to troubleshoot application logic. The tool allows users to navigate a chronological history of state changes to replay previous versions of the application or skip specific actions. It also functions as a remote monitoring bridge, streaming Redux state and actions from non-browser environments to a centralized debugging interface. The capability surface in

Redux DevTools is a development utility designed for inspecting, monitoring, and replaying state changes within applications built using the Redux predictable state container. It functions as a JavaScript state inspector that tracks data flow and visualizes action sequences to assist in identifying logic errors during the development process. The tool provides time-travel debugging capabilities, allowing developers to navigate through recorded action sequences to isolate specific application states. By capturing state transitions as a sequential log, it enables the reproduction of past applic

Vitest is a high-performance testing framework designed for JavaScript and TypeScript applications. It provides an integrated environment that supports unit, integration, and browser-based testing, allowing developers to execute test suites natively without requiring separate build steps or complex configuration. The project distinguishes itself through a highly optimized execution model that leverages worker-thread isolation and on-demand module transformation to provide rapid feedback. It includes a comprehensive suite of mocking and spying utilities that allow for the interception of depen

redux-logger is a state management debugger and logger that operates as Redux middleware. It records actions and state transitions directly to the browser console to facilitate the monitoring of application state changes. The tool provides a mechanism to reduce console noise through action filters that use custom predicates to determine which events are recorded. It also includes a data transformation pipeline to sanitize or modify state and actions before they are output. The project covers observability capabilities including formatted console output with timestamps and colors, synchronous

MAME is a vintage hardware emulation platform designed to recreate the circuitry of arcade games, computers, and consoles to run original software on modern devices. It functions as a retro gaming preservation framework for managing, verifying, and archiving ROM sets and disk images to ensure long-term software accessibility. The project features a system debugging tool for inspecting emulated memory, CPU registers, and execution flow via breakpoints and disassembly. It also includes a Lua-based automation layer that exposes core system state and hardware controls for custom behavior and anal

xemu is a game console emulator and virtual hardware hypervisor designed to execute original Xbox game software on various operating systems. It functions as a disk image player that simulates physical circuitry and storage to enable the playback of original titles. The project includes a suite of low-level system debugging tools for inspecting registers, tracing execution events, and dumping memory from running guest code. It provides specialized capabilities for hardware accuracy testing and game hardware debugging to analyze system behavior. The software covers a broad range of emulation

Yjs is a CRDT framework and real-time state synchronization engine providing shared data types for collaborative software. It functions as a shared data type library of collaborative maps, arrays, and text structures that converge automatically across distributed clients, serving as a local-first data store and a collaborative editor backend. The system distinguishes itself through a synchronization engine that encodes document changes into commutative binary updates. It employs state-vector based differencing to transmit only missing incremental updates between peers and uses relative-positi

Reactime is a browser extension designed for debugging and profiling React applications. It provides a specialized interface for monitoring component hierarchies, tracking state transitions, and analyzing data flow within complex component trees. The tool distinguishes itself through time-travel debugging capabilities, which allow developers to capture and replay state snapshots to isolate logic errors. It also features a dependency graph mapper that visualizes the relationships between providers and consumers, clarifying how information is distributed throughout an application. Beyond core