Cross-Language Serialization

Apache Fory™ supports seamless data exchange across multiple languages including Java, Python, C++, Go, and JavaScript.

Enable Cross-Language Mode

use fory::Fory;

// Enable cross-language mode
let mut fory = Fory::default()
    .compatible(true)
    .xlang(true);

// Register types with consistent IDs across languages
fory.register::<MyStruct>(100);

// Or use namespace-based registration
fory.register_by_namespace::<MyStruct>("com.example", "MyStruct");

Type Registration for Cross-Language

Register by ID

For fast, compact serialization with consistent IDs across languages:

let mut fory = Fory::default()
    .compatible(true)
    .xlang(true);

fory.register::<User>(100);  // Same ID in Java, Python, etc.

Register by Namespace

For more flexible type naming:

fory.register_by_namespace::<User>("com.example", "User");

Cross-Language Example

Rust (Serializer)

use fory::Fory;
use fory::ForyObject;

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

let mut fory = Fory::default()
    .compatible(true)
    .xlang(true);

fory.register::<Person>(100);

let person = Person {
    name: "Alice".to_string(),
    age: 30,
};

let bytes = fory.serialize(&person)?;
// bytes can be deserialized by Java, Python, etc.

Java (Deserializer)

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

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

Fory fory = Fory.builder()
    .withLanguage(Language.XLANG)
    .withRefTracking(true)
    .build();

fory.register(Person.class, 100);  // Same ID as Rust

Person person = (Person) fory.deserialize(bytesFromRust);

Python (Deserializer)

import pyfory
from dataclasses import dataclass

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

fory = pyfory.Fory(ref_tracking=True)
fory.register_type(Person, type_id=100)  # Same ID as Rust

person = fory.deserialize(bytes_from_rust)

Type Mapping

See xlang_type_mapping.md for complete type mapping across languages.

Common Type Mappings

Rust	Java	Python
i32	int	int32
i64	long	int64
f32	float	float32
f64	double	float64
String	String	str
Vec<T>	List<T>	List[T]
HashMap<K,V>	Map<K,V>	Dict[K,V]
Option<T>	nullable T	Optional[T]

Best Practices

1. Use consistent type IDs across all languages
2. Enable compatible mode for schema evolution
3. Register all types before serialization
4. Test cross-language compatibility during development

See Also

• Cross-Language Serialization Specification
• Type Mapping Reference
• Java Cross-Language Guide
• Python Cross-Language Guide

Related Topics

• Configuration - XLANG mode configuration
• Schema Evolution - Compatible mode
• Type Registration - Registration methods