Apache Fory™ is a blazingly-fast multi-language serialization framework powered by JIT compilation, zero-copy techniques, and advanced code generation, achieving up to 170x performance improvement while maintaining simplicity and ease of use.

https://fory.apache.org

Apache Fory™ delivers excellent performance through advanced optimization techniques:

• JIT Compilation: Runtime code generation for Java eliminates virtual method calls and inlines hot paths
• Static Code Generation: Compile-time code generation for Rust, C++, and Go delivers peak performance without runtime overhead
• Meta Packing & Sharing: Class metadata packing and sharing reduces redundant type information across objects on one stream

The xlang serialization format enables seamless data exchange across programming languages:

• Reference Preservation: Shared and circular references work correctly across languages
• Polymorphism: Objects serialize/deserialize with their actual runtime types
• Schema Evolution: Optional forward/backward compatibility for evolving schemas
• Automatic Serialization: Serialize domain objects automatically, no IDL or schema definitions required

A cache-friendly row format optimized for analytics workloads:

• Zero-Copy Random Access: Read individual fields without deserializing entire objects
• Partial Operations: Selective field serialization and deserialization for efficiency
• Apache Arrow Integration: Seamless conversion to columnar format for analytics pipelines
• Multi-Language: Available in Java, Python, Rust and C++

Built for production environments with secure defaults and explicit control:

• Class Registration: Whitelist-based deserialization control is enabled by default to block untrusted classes.
• Depth Limiting: Configurable object graph depth limits mitigate recursive and stack exhaustion attacks.
• Configurable Policies: Custom class checkers and deserialization policies let teams enforce internal security rules.
• Platform Support: Runs on Java 8 through 25, supports GraalVM native image, and works across major operating systems.

Apache Fory™ provides three protocol families optimized for different scenarios:

All protocol families share the same optimized codebase, allowing improvements in one family to benefit others.

Charts labeled "compatible" show schema evolution mode with forward/backward compatibility enabled, while others show schema consistent mode where class schemas must match.

Serialization Throughput:

Deserialization Throughput:

See Java Benchmarks for more details.

Fory Rust demonstrates competitive performance compared to other Rust serialization frameworks.

For more detailed benchmarks and methodology, see Rust Benchmarks.

Fory C++ demonstrates competitive performance compared to protobuf c++ serialization framework.

For more detailed benchmarks and methodology, see C++ Benchmarks.

Fory Go demonstrates excellent performance compared to other go serialization frameworks:

For more detailed benchmarks and methodology, see Go Benchmark.

Fory C# demonstrates excellent performance compared to protobuf-net and MessagePack-CSharp:

For more detailed benchmarks and methodology, see C# Benchmarks.

For more detailed benchmarks and methodology, see SwiftBenchmarks.

Java:

<dependency>
  <groupId>org.apache.fory</groupId>
  <artifactId>fory-core</artifactId>
  <version>0.15.0</version>
</dependency>

Snapshots are available from https://repository.apache.org/snapshots/ (version 0.15.0-SNAPSHOT).

Scala:

// Scala 2.13
libraryDependencies += "org.apache.fory" % "fory-scala_2.13" % "0.15.0"

// Scala 3
libraryDependencies += "org.apache.fory" % "fory-scala_3" % "0.15.0"

Kotlin:

<dependency>
  <groupId>org.apache.fory</groupId>
  <artifactId>fory-kotlin</artifactId>
  <version>0.15.0</version>
</dependency>

Python:

pip install pyfory

# With row format support
pip install pyfory[format]

Rust:

[dependencies]
fory = "0.14"

C++:

Fory C++ supports both CMake and Bazel build systems. See C++ Installation Guide for detailed instructions.

Golang:

go get github.com/apache/fory/go/fory

This section provides quick examples for getting started with Apache Fory™. For comprehensive guides, see the Documentation.

Always use native mode when working with a single language. Native mode delivers optimal performance by avoiding the type metadata overhead required for cross-language compatibility. Xlang mode introduces additional metadata encoding costs and restricts serialization to types that are common across all supported languages. Language-specific types will be rejected during serialization in xlang-mode.

When you don't need cross-language support, use Java mode for optimal performance.

import org.apache.fory.*;
import org.apache.fory.config.*;

public class Example {
  public static class Person {
    String name;
    int age;
  }

  public static void main(String[] args) {
    // Create Fory instance - should be reused across serializations
    BaseFory fory = Fory.builder()
      .withLanguage(Language.JAVA)
      .requireClassRegistration(true)
      // replace `build` with `buildThreadSafeFory` for Thread-Safe Usage
      .build();
    // Register your classes (required when class registration is enabled)
    // Registration order must be consistent if id is not specified
    fory.register(Person.class);
    // Serialize
    Person person = new Person();
    person.name = "chaokunyang";
    person.age = 28;
    byte[] bytes = fory.serialize(person);
    Person result = (Person) fory.deserialize(bytes);
    System.out.println(result.name + " " + result.age);  // Output: chaokunyang 28
  }
}

For detailed Java usage including compatibility modes, compression, and advanced features, see Java Serialization Guide and java/README.md.

Python native mode provides a high-performance drop-in replacement for pickle/cloudpickle with better speed and compatibility.

from dataclasses import dataclass
import pyfory

@dataclass
class Person:
    name: str
    age: pyfory.int32

# Create Fory instance - should be reused across serializations
fory = pyfory.Fory()
# Register your classes (required when class registration is enabled)
fory.register_type(Person)
person = Person(name="chaokunyang", age=28)
data = fory.serialize(person)
result = fory.deserialize(data)
print(result.name, result.age)  # Output: chaokunyang 28

For detailed Python usage including type hints, compatibility modes, and advanced features, see Python Guide.

Rust native mode provides compile-time code generation via derive macros for high-performance serialization without runtime overhead.

use fory::{Fory, ForyObject};

#[derive(ForyObject, Debug, PartialEq)]
struct Person {
    name: String,
    age: i32,
}

fn main() -> Result<(), fory::Error> {
    // Create Fory instance - should be reused across serializations
    let mut fory = Fory::default();
    // Register your structs (required when class registration is enabled)
    fory.register::<Person>(1);
    let person = Person {
        name: "chaokunyang".to_string(),
        age: 28,
    };
    let bytes = fory.serialize(&person);
    let result: Person = fory.deserialize(&bytes)?;
    println!("{} {}", result.name, result.age); // Output: chaokunyang 28
    Ok(())
}

For detailed Rust usage including collections, references, and custom serializers, see Rust Guide.

C++ native mode provides compile-time reflection via the FORY_STRUCT macro for efficient serialization with zero runtime overhead.

#include "fory/serialization/fory.h"

using namespace fory::serialization;

struct Person {
    std::string name;
    int32_t age;
};
FORY_STRUCT(Person, name, age);

int main() {
    // Create Fory instance - should be reused across serializations
    auto fory = Fory::builder().build();
    // Register your structs (required when class registration is enabled)
    fory.register_struct<Person>(1);
    Person person{"chaokunyang", 28};
    auto bytes = fory.serialize(person).value();
    auto result = fory.deserialize<Person>(bytes).value();
    std::cout << result.name << " " << result.age << std::endl;  // Output: chaokunyang 28
}

For detailed C++ usage including collections, smart pointers, and error handling, see C++ Guide.

Scala native mode provides optimized serialization for Scala-specific types including case classes, collections, and Option types.

import org.apache.fory.Fory
import org.apache.fory.config.Language
import org.apache.fory.serializer.scala.ScalaSerializers

case class Person(name: String, age: Int)

object Example {
  def main(args: Array[String]): Unit = {
    // Create Fory instance - should be reused across serializations
    val fory = Fory.builder()
      .withLanguage(Language.JAVA)
      .requireClassRegistration(true)
      .build()
    // Register Scala serializers for Scala-specific types
    ScalaSerializers.registerSerializers(fory)
    // Register your case classes
    fory.register(classOf[Person])
    val bytes = fory.serialize(Person("chaokunyang", 28))
    val result = fory.deserialize(bytes).asInstanceOf[Person]
    println(s"${result.name} ${result.age}")  // Output: chaokunyang 28
  }
}

For detailed Scala usage including collection serialization and integration patterns, see Scala Guide.

Kotlin native mode provides optimized serialization for Kotlin-specific types including data classes, nullable types, and Kotlin collections.

import org.apache.fory.Fory
import org.apache.fory.config.Language
import org.apache.fory.serializer.kotlin.KotlinSerializers

data class Person(val name: String, val age: Int)

fun main() {
    // Create Fory instance - should be reused across serializations
    val fory = Fory.builder()
        .withLanguage(Language.JAVA)
        .requireClassRegistration(true)
        .build()
    // Register Kotlin serializers for Kotlin-specific types
    KotlinSerializers.registerSerializers(fory)
    // Register your data classes
    fory.register(Person::class.java)
    val bytes = fory.serialize(Person("chaokunyang", 28))
    val result = fory.deserialize(bytes) as Person
    println("${result.name} ${result.age}")  // Output: chaokunyang 28
}

For detailed Kotlin usage including null safety and default value support, see kotlin/README.md.

Only use xlang mode when you need cross-language data exchange. Xlang mode adds type metadata overhead for cross-language compatibility and only supports types that can be mapped across all languages. For single-language use cases, always prefer native mode for better performance.

The following examples demonstrate serializing a Person object across Java and Rust. For other languages (Python, Go, JavaScript, etc.), simply set the language mode to XLANG and follow the same pattern.

Java

import org.apache.fory.*;
import org.apache.fory.config.*;

public class XlangExample {
  public record Person(String name, int age) {}

  public static void main(String[] args) {
    // Create Fory instance with XLANG mode
    Fory fory = Fory.builder()
      .withLanguage(Language.XLANG)
      .build();

    // Register with cross-language type id/name
    fory.register(Person.class, 1);
    // fory.register(Person.class, "example.Person");
    Person person = new Person("chaokunyang", 28);
    byte[] bytes = fory.serialize(person);
    // bytes can be deserialized by Rust, Python, Go, or other languages
    Person result = (Person) fory.deserialize(bytes);
    System.out.println(result.name + " " + result.age);  // Output: chaokunyang 28
  }
}

Rust

use fory::{Fory, ForyObject};

#[derive(ForyObject, Debug)]
struct Person {
    name: String,
    age: i32,
}

fn main() -> Result<(), Error> {
    let mut fory = Fory::default();
    fory.register::<Person>(1)?;
    // fory.register_by_name::<Person>("example.Person")?;
    let person = Person {
        name: "chaokunyang".to_string(),
        age: 28,
    };
    let bytes = fory.serialize(&person);
    // bytes can be deserialized by Java, Python, Go, or other languages
    let result: Person = fory.deserialize(&bytes)?;
    println!("{} {}", result.name, result.age);  // Output: chaokunyang 28
}

Key Points for Cross-Language Serialization:

• Use Language.XLANG mode in all languages
• Register types with consistent IDs or names across all languages:
  • By ID (fory.register(Person.class, 1)): Faster serialization, more compact encoding, but requires coordination to avoid ID conflicts
  • By name (fory.register(Person.class, "example.Person")): More flexible, less prone to conflicts, easier to manage across teams, but slightly larger encoding
• Type IDs/names must match across all languages for successful deserialization
• Only use types that have cross-language mappings (see Type Mapping)

For examples with circular references, shared references, and polymorphism across languages, see:

• Cross-Language Serialization Guide
• Java Serialization Guide - Cross Language
• Python Guide - Cross Language

Row format provides zero-copy random access to serialized data, making it ideal for analytics workloads and data processing pipelines.

import org.apache.fory.format.*;
import java.util.*;
import java.util.stream.*;

public class Bar {
  String f1;
  List<Long> f2;
}

public class Foo {
  int f1;
  List<Integer> f2;
  Map<String, Integer> f3;
  List<Bar> f4;
}

RowEncoder<Foo> encoder = Encoders.bean(Foo.class);
Foo foo = new Foo();
foo.f1 = 10;
foo.f2 = IntStream.range(0, 1000000).boxed().collect(Collectors.toList());
foo.f3 = IntStream.range(0, 1000000).boxed().collect(Collectors.toMap(i -> "k"+i, i -> i));

List<Bar> bars = new ArrayList<>(1000000);
for (int i = 0; i < 1000000; i++) {
  Bar bar = new Bar();
  bar.f1 = "s" + i;
  bar.f2 = LongStream.range(0, 10).boxed().collect(Collectors.toList());
  bars.add(bar);
}
foo.f4 = bars;

// Serialize to row format (can be zero-copy read by Python)
BinaryRow binaryRow = encoder.toRow(foo);

// Deserialize entire object
Foo newFoo = encoder.fromRow(binaryRow);

// Zero-copy access to nested fields without full deserialization
BinaryArray binaryArray2 = binaryRow.getArray(1);  // Access f2 field
BinaryArray binaryArray4 = binaryRow.getArray(3);  // Access f4 field
BinaryRow barStruct = binaryArray4.getStruct(10);   // Access 11th Bar element
long value = barStruct.getArray(1).getInt64(5);     // Access nested value

// Partial deserialization
RowEncoder<Bar> barEncoder = Encoders.bean(Bar.class);
Bar newBar = barEncoder.fromRow(barStruct);
Bar newBar2 = barEncoder.fromRow(binaryArray4.getStruct(20));

from dataclasses import dataclass
from typing import List, Dict
import pyarrow as pa
import pyfory

@dataclass
class Bar:
    f1: str
    f2: List[pa.int64]

@dataclass
class Foo:
    f1: pa.int32
    f2: List[pa.int32]
    f3: Dict[str, pa.int32]
    f4: List[Bar]

encoder = pyfory.encoder(Foo)
foo = Foo(
    f1=10,
    f2=list(range(1000_000)),
    f3={f"k{i}": i for i in range(1000_000)},
    f4=[Bar(f1=f"s{i}", f2=list(range(10))) for i in range(1000_000)]
)

# Serialize to row format
binary: bytes = encoder.to_row(foo).to_bytes()

# Zero-copy random access without full deserialization
foo_row = pyfory.RowData(encoder.schema, binary)
print(foo_row.f2[100000])           # Access element directly
print(foo_row.f4[100000].f1)        # Access nested field
print(foo_row.f4[200000].f2[5])     # Access deeply nested field

For more details on row format, see Row Format Specification.

Apache Fory™ supports class schema forward/backward compatibility across Java, Python, Rust, and Golang, enabling seamless schema evolution in production systems without requiring coordinated upgrades across all services. Fory provides two schema compatibility modes:

1. Schema Consistent Mode (Default): Assumes identical class schemas between serialization and deserialization peers. This mode offers minimal serialization overhead, smallest data size, and fastest performance: ideal for stable schemas or controlled environments.

2. Compatible Mode: Supports independent schema evolution with forward and backward compatibility. This mode enables field addition/deletion, limited type evolution, and graceful handling of schema mismatches. Enable using withCompatibleMode(CompatibleMode.COMPATIBLE) in Java, compatible=True in Python, compatible_mode(true) in Rust, or NewFory(true) in Go.

Current Status: Binary compatibility is not guaranteed between Fory major releases as the protocol continues to evolve. However, compatibility is guaranteed between minor versions (e.g., 0.13.x).

Recommendations:

• Version your serialized data by Fory major version
• Plan migration strategies when upgrading major versions
• See upgrade guide for details

Future: Binary compatibility will be guaranteed starting from Fory 1.0 release.

Serialization security varies by protocol:

• Row Format: Secure with predefined schemas
• Object Graph Serialization (Java/Python native): More flexible but requires careful security configuration

Dynamic serialization can deserialize arbitrary types, which may introduce risks. For example, the deserialization may invoke init constructor or equals/hashCode method; If the method body contains malicious code, the system will be at risk.

Fory enables class registration by default for dynamic protocols, allowing only trusted registered types. Do not disable class registration unless you can ensure your environment is secure.

If this option is disabled, you are responsible for serialization security. You should implement and configure a customized TypeChecker or DeserializationPolicy for fine-grained security control.

To report security vulnerabilities in Apache Fory™, please follow the ASF vulnerability reporting process.

• Slack: Join our Slack workspace for community discussions
• Twitter/X: Follow @ApacheFory for updates and announcements
• GitHub Issues: Report bugs and request features at apache/fory
• Mailing Lists: Subscribe to Apache Fory mailing lists for development discussions

We welcome contributions! Please read our Contributing Guide to get started.

Ways to Contribute:

• 🐛 Report bugs and issues
• 💡 Propose new features
• 📝 Improve documentation
• 🔧 Submit pull requests
• 🧪 Add test cases
• 📊 Share benchmarks

See Development Guide for build instructions and development workflow.

Apache Fory™ is licensed under the Apache License 2.0.