# Apache Fury — Blazing-Fast Cross-Language Serialization Framework

> Apache Fury is a high-performance, multi-language serialization framework that provides automatic object graph serialization with speeds up to 170x faster than JDK serialization.

## Install

Save in your project root:

# Apache Fury — Blazing-Fast Cross-Language Serialization Framework

## Quick Use
```bash
# Java (Maven)
<dependency>
  <groupId>org.apache.fury</groupId>
  <artifactId>fury-core</artifactId>
</dependency>
# Python
pip install pyfury
```

## Introduction
Apache Fury is a serialization framework designed for extreme performance. It automatically serializes object graphs across Java, Python, Go, JavaScript, Rust, and C++ without requiring manual schema definitions, while delivering speeds that far exceed traditional serializers.

## What Apache Fury Does
- Serializes and deserializes complex object graphs automatically without schema files
- Supports cross-language serialization between Java, Python, Go, JavaScript, Rust, and C++
- Provides JIT compilation for Java to generate optimized serialization code at runtime
- Handles circular references, polymorphic types, and nested generics
- Offers both row-based and columnar serialization formats

## Architecture Overview
Fury uses a type-metadata-sharing protocol where schema information is exchanged once between peers and cached for subsequent serializations. In Java, a JIT compiler generates specialized serialization bytecode for each class, eliminating reflection overhead. The binary format uses variable-length encoding and reference tracking to produce compact output. Cross-language support works through a shared binary protocol that maps language-specific types to a common type system.

## Self-Hosting & Configuration
- Add the Fury dependency to your build tool (Maven, pip, go get, npm)
- Create a Fury instance with ThreadSafeFury for concurrent access
- Register frequently serialized classes for optimal performance
- Enable reference tracking for object graphs with circular references
- Configure language-specific settings like class registration enforcement

## Key Features
- Automatic object graph serialization with no manual schema definitions needed
- JIT-compiled serializers in Java eliminate reflection overhead at runtime
- Cross-language compatibility via a shared binary protocol
- Zero-copy deserialization for large binary payloads
- Drop-in replacement for Java Serialization with configurable compatibility modes

## Comparison with Similar Tools
- **Protobuf** — requires .proto schema files; Fury serializes plain objects automatically
- **Kryo** — Java-only, no JIT; Fury supports multiple languages with JIT optimization
- **FlatBuffers** — zero-copy but requires schema; Fury auto-serializes without schemas
- **Avro** — schema-based with JSON/binary formats; Fury focuses on object graph speed
- **MessagePack** — cross-language but schema-less maps; Fury preserves full type information

## FAQ
**Q: How much faster is Fury compared to standard serialization?**
A: Benchmarks show Fury is up to 170x faster than JDK serialization and significantly faster than Kryo and Hessian for complex object graphs, depending on the data structure.

**Q: Does Fury require defining schemas like Protobuf?**
A: No. Fury serializes plain Java, Python, or Go objects directly. It infers type information automatically and shares metadata between peers.

**Q: Is Fury safe from deserialization attacks?**
A: Fury provides class registration enforcement to prevent deserialization of unauthorized classes, similar to allowlisting in other frameworks.

**Q: Can I use Fury as a drop-in replacement for Java Serialization?**
A: Yes. Fury offers a compatibility mode that supports java.io.Serializable and Externalizable interfaces.

## Sources
- https://github.com/apache/fury
- https://fury.apache.org/

---
Source: https://tokrepo.com/en/workflows/asset-a51a63fd
Author: AI Open Source