Apache Fury — Blazing-Fast Cross-Language Serialization Framework

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/