https://fory.apache.org/blog Apache Fory™ Blog 2026-04-19T00:00:00.000Z https://github.com/jpmonette/feed Apache Fory™ Blog https://fory.apache.org/img/favicon.ico <![CDATA[Fory v0.17.0 Released]]> https://fory.apache.org/blog/fory_0_17_0_release 2026-04-19T00:00:00.000Z The Apache Fory team is pleased to announce the 0.17.0 release. This is a major release that includes 71 PR from 19 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

JavaScript/NodeJS Serialization: First Release​

Apache Fory 0.17.0 marks the first release with official JavaScript/NodeJS documentation, benchmark coverage, and TypeScript-friendly IDL code generation. The JavaScript runtime is built for modern Node.js services and TypeScript codebases, while preserving Fory's cross-language object model, schema-driven APIs, and optional reference tracking.

Key capabilities:

  • High-performance serialization for JavaScript and TypeScript objects in Node.js
  • Cross-language compatibility with Java, Python, Go, Rust, C#, Swift, and Dart
  • Schema-driven APIs via Type.* builders and TypeScript decorators
  • Optional reference tracking for shared and circular object graphs
  • Compatible mode for schema evolution
  • Configurable depth, binary size, and collection size guardrails
  • JavaScript/TypeScript target support in the Fory IDL/compiler workflow
  • Optional @apache-fory/hps fast string path for Node.js 20+

Quick Start​

import Fory, { Type } from "@apache-fory/core";

const userType = Type.struct(
  { typeName: "example.user" },
  {
    id: Type.int64(),
    name: Type.string(),
    age: Type.int32(),
  },
);

const fory = new Fory();
const { serialize, deserialize } = fory.register(userType);

const bytes = serialize({
  id: 1n,
  name: "Alice",
  age: 30,
});

const user = deserialize(bytes);
console.log(user);

JavaScript Benchmarks​

Below are throughput results (ops/sec; higher is better) comparing Fory with Protocol Buffers and JSON across representative data structures.

DatatypeOperationFory TPSProtobuf TPSJSON TPSFastest
StructSerialize8,453,9501,903,7063,058,232fory
StructDeserialize9,705,2878,233,6643,860,538fory
SampleSerialize1,498,391422,620744,790fory
SampleDeserialize1,918,162819,010762,048fory
MediaContentSerialize1,293,157729,4971,299,908json
MediaContentDeserialize1,638,0861,209,140921,191fory
StructListSerialize3,928,325495,648891,810fory
StructListDeserialize3,264,8271,529,744986,144fory
SampleListSerialize355,58192,741163,120fory
SampleListDeserialize424,916163,253162,520fory
MediaContentListSerialize286,053148,977282,445fory
MediaContentListDeserialize376,826244,622190,155fory

Serialized data sizes (bytes):

DatatypeForyProtobufJSON
Struct5861103
Sample446377724
MediaContent391307596
StructList184315537
SampleList198019003642
MediaContentList166515503009

Benchmark details: https://github.com/apache/fory/tree/v0.17.0/benchmarks/javascript

Dart Serialization: First Release​

Apache Fory 0.17.0 also marks the first release with official Dart documentation, benchmark coverage, a rebuilt runtime, and Dart IDL support. The Dart implementation focuses on generated serializers, stable cross-language type identity, schema evolution, and predictable APIs for service workloads.

Key capabilities:

  • High-performance Dart serialization with generated code instead of reflection
  • Cross-language compatibility with Java, Python, Go, Rust, C#, Swift, and JavaScript
  • @ForyStruct and @ForyField annotations with build_runner code generation
  • Compatible mode for schema evolution across versions
  • Optional reference tracking for shared and circular object graphs
  • Manual Serializer<T> extension points for advanced or custom types
  • Dart target support in the Fory IDL/compiler workflow

Quick Start​

import 'package:fory/fory.dart';

part 'person.fory.dart';

enum Color {
  red,
  blue,
}

@ForyStruct()
class Person {
  Person();

  String name = '';
  Int32 age = Int32(0);
  Color favoriteColor = Color.red;
}

void main() {
  final fory = Fory();
  PersonFory.register(
    fory,
    Color,
    namespace: 'example',
    typeName: 'Color',
  );
  PersonFory.register(
    fory,
    Person,
    namespace: 'example',
    typeName: 'Person',
  );

  final bytes = fory.serialize(Person()
    ..name = 'Ada'
    ..age = Int32(36)
    ..favoriteColor = Color.blue);
  final roundTrip = fory.deserialize<Person>(bytes);
  print(roundTrip.name);
}

Dart Benchmarks​

Below are throughput results (ops/sec; higher is better) comparing Fory with Protocol Buffers across representative data structures.

DatatypeOperationFory TPSProtobuf TPSFastest
StructSerialize3,989,4321,884,653fory (2.12x)
StructDeserialize5,828,1974,199,680fory (1.39x)
SampleSerialize1,649,722500,167fory (3.30x)
SampleDeserialize2,060,113785,109fory (2.62x)
MediaContentSerialize800,876391,235fory (2.05x)
MediaContentDeserialize1,315,115683,533fory (1.92x)
StructListSerialize1,456,396367,506fory (3.96x)
StructListDeserialize1,921,006645,958fory (2.97x)
SampleListSerialize411,14448,508fory (8.48x)
SampleListDeserialize464,273103,558fory (4.48x)
MediaContentListSerialize186,87077,029fory (2.43x)
MediaContentListDeserialize330,293128,215fory (2.58x)

Serialized data sizes (bytes):

DatatypeForyProtobuf
Struct5861
Sample446377
MediaContent365307
StructList184315
SampleList19801900
MediaContentList15351550

Benchmark details: https://github.com/apache/fory/tree/v0.17.0/benchmarks/dart

Highlights​

Features​

Bug Fix​

Other Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.16.0...v0.17.0

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.16.0 Released]]> https://fory.apache.org/blog/fory_0_16_0_release 2026-03-17T00:00:00.000Z The Apache Fory team is pleased to announce the 0.16.0 release. This is a major release that includes 91 PR from 17 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

C# Serialization: First Release​

Apache Fory 0.16.0 is the first release with official C# serialization support. The C# runtime targets modern .NET workloads and brings the same object graph, cross-language, and schema-evolution model available in other Fory runtimes.

Key capabilities:

  • High-performance binary serialization for .NET 8+ with source-generator-based serializers for [ForyObject] types
  • Cross-language mode with Java, Python, C++, Go, Rust, and JavaScript
  • Optional reference tracking for shared and circular object graphs
  • Compatible mode for schema evolution
  • Dynamic object payloads, custom serializers, and namespace/name registration APIs
  • ThreadSafeFory wrapper for concurrent service workloads
  • C# target support in the Fory IDL/compiler workflow

Quick Start​

using Apache.Fory;

[ForyObject]
public sealed class User
{
    public long Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string? Email { get; set; }
}

Fory fory = Fory.Builder()
    .Xlang(true)
    .Compatible(true)
    .Build();
fory.Register<User>(1);

byte[] payload = fory.Serialize(new User
{
    Id = 1,
    Name = "Alice",
    Email = "alice@example.com",
});
User decoded = fory.Deserialize<User>(payload);

C# Benchmarks​

Below are timing results (ns/op; lower is better) comparing Fory with Protobuf and Msgpack across representative data structures.

Data TypeOperationForyProtobufMsgpack
StructSerialize39.2121.566.0
StructDeserialize58.3180.1102.6
SampleSerialize269.2562.6339.6
SampleDeserialize175.61084.9531.8
MediaContentSerialize306.3434.7351.5
MediaContentDeserialize379.4718.8676.9
StructListSerialize136.1468.5266.9
StructListDeserialize221.1687.0488.5
SampleListSerialize1198.92811.91635.7
SampleListDeserialize791.55174.52629.2
MediaContentListSerialize1393.92199.41710.9
MediaContentListDeserialize1719.53373.13401.2

Serialized data sizes (bytes):

Data TypeForyProtobufMsgpack
Struct586155
Sample446460562
MediaContent365307479
StructList184315284
SampleList198023152819
MediaContentList153515502404

Benchmark details: https://fory.apache.org/docs/benchmarks/csharp/

Swift Serialization: First Release​

Apache Fory 0.16.0 is also the first release with official Swift serialization support. The Swift implementation focuses on idiomatic API design, macro-based model serialization, cross-language compatibility, and strong support for object graph workloads.

Key capabilities:

  • High-performance serialization for Swift value and reference types
  • @ForyObject macro for zero-boilerplate model serialization
  • Cross-language protocol compatibility with Java, Python, C++, Go, Rust, and JavaScript
  • Compatible mode for schema evolution across versions
  • Dynamic value support for Any, AnyObject, any Serializer, and AnyHashable
  • Reference tracking for shared/circular graphs, including weak references on classes
  • Swift target support in the Fory IDL/compiler workflow

Quick Start​

import Fory

@ForyObject
struct User: Equatable {
    var name: String = ""
    var age: Int32 = 0
}

let fory = Fory(xlang: true, trackRef: false, compatible: true)
fory.register(User.self, id: 1)

let input = User(name: "Alice", age: 30)
let data = try fory.serialize(input)
let output: User = try fory.deserialize(data)

Swift Benchmarks​

Below are throughput results (ops/sec; higher is better) comparing Fory with Protobuf and Msgpack across representative data structures.

Data TypeOperationForyProtobufMsgpackFastest
StructSerialize9,727,9506,572,406141,248fory (1.48x)
StructDeserialize11,889,5708,584,51099,792fory (1.39x)
SampleSerialize3,496,3051,281,98317,188fory (2.73x)
SampleDeserialize1,045,018765,70612,767fory (1.36x)
MediaContentSerialize1,425,354678,54229,048fory (2.10x)
MediaContentDeserialize614,447478,29812,711fory (1.28x)
StructListSerialize3,307,9621,028,21024,781fory (3.22x)
StructListDeserialize2,788,200708,5968,160fory (3.93x)
SampleListSerialize715,734205,3803,361fory (3.48x)
SampleListDeserialize199,317133,4251,498fory (1.49x)
MediaContentListSerialize364,097103,7215,538fory (3.51x)
MediaContentListDeserialize103,42186,3311,529fory (1.20x)

Serialized data sizes (bytes):

Data TypeForyProtobufMsgpack
MediaContent365301524
MediaContentList153515202639
Sample446375737
SampleList198018903698
Struct586165
StructList184315338

Benchmark details: https://fory.apache.org/docs/benchmarks/swift/

Features​

Bug Fix​

Other Improvements​

New Contributors​

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Extend Protobuf/FlatBuffers Schema IDL with Shared/Circular Reference Support]]> https://fory.apache.org/blog/extend_protobuf_flatbuffers_with_shared_circular_refs 2026-03-11T00:00:00.000Z TL;DR: If you already have .proto or .fbs schemas and you want shared/circular reference support, with the Fory compiler you can keep those schemas, add a small set of Fory options, then foryc generates idiomatic native models across Fory-supported languages, so you can serialize object graphs without manual *_id link reconstruction or rewriting your entire schema into Fory Schema.

The Gap in Protobuf and FlatBuffers Schemas​

Many production models are object graphs, not pure value trees:

  • Parent pointers (child.parent)
  • Shared nodes (two edges pointing to the same object)
  • Cycles (A -> B -> A)

In plain protobuf or FlatBuffers schema design, these relationships are usually represented indirectly with manual ID links (parent_id, child_ids) and rebuilt in application code after decode.

Apache Fory adds schema-level reference tracking so these graph semantics can be declared directly in protobuf/FlatBuffers source via Fory options.

Keep .proto and .fbs, Add Graph Semantics​

You do not need to rewrite everything into .fdl first.

  • For protobuf input, use (fory).ref, (fory).weak_ref, and related options.
  • For FlatBuffers input, use fory_ref:true, fory_weak_ref:true, and related attributes.
  • Compile with foryc.
  • Get Fory-generated models and Fory wire format.

Important: this path reuses schema syntax and structure, but serialization output is Fory binary protocol, not protobuf/FlatBuffers wire compatibility.

Protobuf: From ID Workarounds to ref​

Protobuf-style workaround (value-tree oriented)​

message TreeNode {
  string id = 1;
  string parent_id = 2;
  repeated string child_ids = 3;
}

Protobuf + Fory options (graph semantics)​

syntax = "proto3";

message TreeNode {
  TreeNode parent = 1 [(fory).weak_ref = true];
  repeated TreeNode children = 2 [(fory).ref = true];
}

What this means:

  • weak_ref = true implies ref tracking and generates weak-pointer semantics where relevant (for example C++/Rust).
  • For repeated fields, (fory).ref = true applies to list elements.
  • For map<K, V>, (fory).ref = true applies to map values.

You can also tune Rust pointer flavor:

message Graph {
  Node root = 1 [(fory).ref = true, (fory).thread_safe_pointer = false];
}

FlatBuffers: Add fory_ref Attributes​

FlatBuffers schema with Fory reference attributes​

namespace demo;

table Node {
  parent: Node (fory_weak_ref: true);
  children: [Node] (fory_ref: true);
  cached: Node (fory_ref: true, fory_thread_safe_pointer: false);
}

Semantics:

  • fory_weak_ref:true implies reference tracking.
  • fory_thread_safe_pointer affects pointer flavor on ref-tracked fields.
  • For list fields, fory_ref:true applies to elements.

FlatBuffers input is translated into Fory IR, then normal Fory codegen runs. The generated API surface is native objects (not FlatBuffers ByteBuffer-wrapper APIs).

Inspect Before You Commit​

You can inspect how .proto or .fbs is translated:

# Protobuf to translated Fory schema
foryc schema.proto --emit-fdl

# FlatBuffers to translated Fory schema
foryc schema.fbs --emit-fdl --emit-fdl-path ./translated

Then generate code:

foryc schema.proto \
  --java_out=./java/gen \
  --python_out=./python/gen \
  --go_out=./go/gen \
  --rust_out=./rust/gen \
  --cpp_out=./cpp/gen

This is the migration-friendly loop:

  1. Keep existing schema files.
  2. Add only Fory reference options where graph semantics are required.
  3. Inspect translated .fdl.
  4. Generate and run roundtrip tests.

What You Get After Generation​

With Fory codegen, you get native language models and reference-aware serialization behavior:

  • Java: POJOs/records with Fory metadata
  • Python: dataclasses + registration helpers
  • Go: structs with tags
  • Rust: native structs with ref-pointer mapping
  • C++: native classes/structs with shared/weak pointer mapping
  • C#, Swift, and more: idiomatic generated models

For object-graph-heavy workflows, this removes a common layer of manual ID-link hydration code.

Behavioral Boundaries to Keep in Mind​

  1. This is not protobuf or FlatBuffers wire compatibility. The schema frontend is reused, but bytes on the wire are Fory protocol.

  2. Protobuf unknown-field behavior is different. Protobuf preserves unknown fields; Fory does not preserve protobuf unknown-field payloads.

  3. Reference tracking should be explicit and minimal. Use ref/weak_ref for true shared/cyclic parts of the graph, not for all fields.

Practical Migration Pattern​

If you already run protobuf or FlatBuffers in production:

  1. Keep package/namespace names stable.
  2. Add Fory reference options only to graph-shaped fields.
  3. Generate code with foryc and run roundtrip tests.
  4. Migrate internal object-heavy paths first.
  5. Keep external protobuf/gRPC boundaries as-is when needed.

This lets you adopt graph semantics incrementally without a full schema rewrite.

Conclusion​

Protobuf and FlatBuffers schema files can be a starting point for Fory graph-aware serialization, not a blocker.

By adding a small set of Fory extension options (ref, weak_ref, pointer-style hints), you can express shared identity and circular links directly in existing .proto/.fbs sources, generate native models, and remove manual object-link reconstruction code in object-graph-heavy systems.

If your data model is a graph, make that graph explicit in the schema.

Get started:

pip install fory-compiler
foryc --help

References:

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Apache Fory™ Schema IDL: Serialization IDL for Object Graphs and Generated API Ergonomics]]> https://fory.apache.org/blog/fory_schema_idl_for_object_graph 2026-03-09T00:00:00.000Z TL;DR: Apache Fory Schema IDL is the first cross-language serialization IDL for object graphs serialization. Define your types once in a .fdl file, and the compiler generates idiomatic domain objects for Java, Python, Go, Rust, C++, C#, Swift, and more — with shared refs, cycles, polymorphism, schema evolution, and optional types built into the schema model.

The Object Graph Gap​

Most existing serialization IDLs model data as value trees: flat messages with no schema-level notion of shared identity, cycles, or reusable standalone polymorphic types. When the actual data is a graph, that gap usually shows up in three places:

  1. Shared and Circular References: If two fields refer to the same logical object, Protocol Buffers and FlatBuffers do not preserve that shared identity in the schema or on the wire. Parent pointers, DAGs, and cycles have no schema-level representation, so they fall back to manual ID fields and application-side reconstruction.

  2. Polymorphism: Protobuf oneof and FlatBuffers union are inline alternatives embedded in an enclosing message, not reusable standalone schema types. Protobuf Any supports open-ended polymorphism, but only for messages and via a type URL. FlatBuffers has no equivalent.

  3. Generated Types as Domain Models: FlatBuffers APIs are primarily buffer-access wrappers. Protobuf generates transport-first types in many languages, so users often add a conversion layer to get back to idiomatic domain objects. The schema defines the wire format, but not the application model.

Apache Fory Schema IDL closes that gap.

What Makes Fory IDL Different?​

Apache Fory Schema IDL is built around object graphs as a first-class concept. You define your types once — including shared references, circular structures, standalone unions, and polymorphic fields — run the compiler, and get idiomatic code in every supported language on top of the same Fory wire format.

In this article, "serialization IDL for object graphs" means the schema itself can describe shared identity, cycles, and reusable polymorphic types directly, instead of forcing users to flatten everything into value trees and rebuild links with manual IDs or application-side conventions later.

That shows up in three places:

  • ref makes shared references and cycles part of the schema contract.
  • union and any make polymorphism a reusable schema feature rather than only an inline transport detail.
  • The generated code stays usable as host-language application models instead of wrapper types that require another conversion layer.

The sections below show how that works in practice.

First-Class Shared References​

Fory IDL has a ref modifier that makes shared and circular reference tracking explicit in the schema:

message TreeNode {
    string value = 1;
    ref TreeNode parent = 2;          // Shared reference — can point back
    list<ref TreeNode> children = 3;  // Each child is reference-tracked
}

When you serialize a tree where children point back to their parent, Fory encodes each object exactly once and uses back-references for duplicates. No manual ID-link fields. No application-level reconstruction logic. The object graph contract lives in the schema itself.

For parent pointers where you want to break ownership cycles, ref(weak=true) generates weak pointer types (e.g., ArcWeak<Node> in Rust, std::weak_ptr in C++).

Idiomatic Domain Objects, Not Wrappers​

A key difference from Protocol Buffers and FlatBuffers is that compiling a Fory .fdl schema produces host-language models you can use directly:

  • Java: Plain POJOs with @ForyField annotations — usable directly in Spring, Hibernate, or any framework
  • Python: @dataclass types with standard type hints
  • Go: Structs with fory:"id=..." struct tags
  • Rust: Structs with #[derive(ForyObject)]
  • C++: final classes with FORY_STRUCT macros — zero runtime reflection
  • C#: Classes with [ForyObject] attributes
  • Swift: @ForyObject models with @ForyField metadata

In many applications, no adapter layer is needed. The generated types can be used directly as your domain objects.

Built-In Unions (Sum Types)​

Fory IDL has a first-class union construct that maps to the most idiomatic sum type in each language:

message Dog {
    string name = 1;
    int32 bark_volume = 2;
}

message Cat {
    string name = 1;
    int32 lives = 2;
}

union Animal {
    Dog dog = 1;
    Cat cat = 2;
}

This generates:

  • Rust: enum Animal { Dog(Dog), Cat(Cat) }
  • C++: std::variant-based wrapper with is_dog(), as_dog(), visit() APIs
  • Swift: Tagged enum with associated values
  • Java: Union subclass with typed case accessors
  • Python: Union subclass with is_dog() / dog_value() helpers
  • Go: Typed case struct with AsDog() / visitor pattern
  • C#: Union subclass with IsDog / DogValue() helpers

Every language gets the same semantics, but expressed in each language's idiom.

Polymorphic Fields with any​

Sometimes you don't know the concrete type of a field at schema-definition time. An event bus carries heterogeneous payloads. A plugin system accepts user-defined message types. Fory IDL's any type handles this — it writes the runtime type identity into the binary stream and resolves it on the other side:

message Envelope {
    string event_type = 1;
    any payload = 2;          // Carries dynamic values supported by Fory
}

At runtime, payload can hold dynamic values supported by Fory — other generated messages, built-in scalars, or collection types. The serialized bytes include runtime type metadata, so the deserializer can reconstruct the concrete value on the other side:

LanguageGenerated Field Type
JavaObject payload
Pythonpayload: Any
GoPayload any
Rustpayload: Box<dyn Any>
C++std::any payload
C#object Payload
Swiftvar payload: Any

This gives you protobuf Any-like flexibility, but in the generated Fory model and without requiring protobuf-style type URLs in the schema surface.

The three features above — ref, union/any, and idiomatic generated code — make Fory IDL an object-graph-first schema language. Schema evolution is a separate concern, but it completes the production story:

Schema Evolution Out of the Box​

Add fields, remove fields, deploy independently. In compatible mode, fields are matched by field id, missing fields get defaults, and unknown fields are skipped:

// Version 1 — deployed to production
message User {
    string name = 1;
    int32 age = 2;
}

// Version 2 — new field added by another team
message User {
    string name = 1;
    int32 age = 2;
    optional string email = 3;  // New: safely ignored by V1 consumers
}

This still follows compatibility rules; it is not a license for arbitrary schema changes. But for normal additive and removal changes, you do not need coordinated big-bang deployments or a separate version-negotiation layer.

A Complete Walkthrough​

Let's build a realistic e-commerce schema, see it work across current Fory-supported languages, and then make the object-graph part explicit with a shared-customer round trip.

1. Define the Schema​

Create ecommerce.fdl:

package ecommerce;

enum OrderStatus {
    PENDING = 0;
    CONFIRMED = 1;
    SHIPPED = 2;
    DELIVERED = 3;
}

message Address {
    string street = 1;
    string city = 2;
    string country = 3;
}

message Customer {
    string id = 1;
    string name = 2;
    optional string email = 3;
    optional Address address = 4;
}

message OrderItem {
    string sku = 1;
    int32 quantity = 2;
    float64 unit_price = 3;
}

message Order {
    string order_id = 1;
    ref Customer customer = 2;
    list<OrderItem> items = 3;
    OrderStatus status = 4;
    float64 total = 5;
    optional string notes = 6;
    timestamp created_at = 7;
}

message OrderBatch {
    list<Order> orders = 1;
}

2. Install the Compiler and Generate Code​

pip install fory-compiler

# Generate code for all currently supported Fory IDL languages in one command
foryc ecommerce.fdl \
  --java_out=./java/src/main/java \
  --python_out=./python/gen \
  --go_out=./go/gen \
  --rust_out=./rust/gen \
  --cpp_out=./cpp/gen \
  --csharp_out=./csharp/gen \
  --swift_out=./swift/gen

A single command can generate code for multiple languages. Registration helpers, byte helpers, and type IDs are generated automatically.

3. Use the Generated Code​

Java — serialize an order:

import ecommerce.*;

Order order = new Order();
order.setOrderId("ORD-2026-001");

Customer customer = new Customer();
customer.setName("Alice");
customer.setEmail("alice@example.com");
order.setCustomer(customer);

order.setStatus(OrderStatus.CONFIRMED);
order.setTotal(259.98);

// toBytes() / fromBytes() are generated — no Fory boilerplate
byte[] bytes = order.toBytes();
Order restored = Order.fromBytes(bytes);

Python — deserialize the same bytes:

from ecommerce import Order

# from_bytes() handles registration and deserialization
order = Order.from_bytes(bytes_from_java)
print(f"{order.order_id}: {order.customer.name} — ${order.total}")
# ORD-2026-001: Alice — $259.98

Go — process the order:

import "gen/ecommerce"

var order ecommerce.Order
if err := order.FromBytes(bytesFromJava); err != nil {
    panic(err)
}
fmt.Printf("%s: %s — $%.2f\n", order.OrderId, order.Customer.Name, order.Total)

Rust — type-safe deserialization:

use gen::ecommerce::Order;

let order = Order::from_bytes(&bytes_from_java)?;
println!("{}: {} — ${:.2}", order.order_id, order.customer.name, order.total);

C++ — zero-overhead access:

#include "gen/ecommerce.h"

auto order = ecommerce::Order::from_bytes(bytes_from_java).value();
std::cout << order.order_id() << ": " << order.customer().name()
          << " — $" << order.total() << std::endl;

C# — strongly-typed deserialization:

using Ecommerce;

var order = Order.FromBytes(bytesFromJava);
Console.WriteLine($"{order.OrderId}: {order.Customer.Name} — ${order.Total}");

Swift — idiomatic model access:

import Ecommerce

let order = try Order.fromBytes(bytesFromJava)
print("\(order.orderId): \(order.customer.name) — $\(order.total)")

The same schema and generated code produce compatible bytes across supported languages with no hand-written conversion layer.

4. Preserve Shared Identity, Not Just Values​

Because Order.customer is declared as ref Customer, shared identity is part of the schema contract:

Customer customer = new Customer();
customer.setName("Alice");

Order first = new Order();
first.setOrderId("ORD-1");
first.setCustomer(customer);

Order second = new Order();
second.setOrderId("ORD-2");
second.setCustomer(customer);

OrderBatch batch = new OrderBatch();
batch.setOrders(java.util.Arrays.asList(first, second));

OrderBatch restored = OrderBatch.fromBytes(batch.toBytes());
assert restored.getOrders().get(0).getCustomer()
    == restored.getOrders().get(1).getCustomer();

With a value-tree serializer, you typically rebuild this identity yourself. With Fory IDL, the ref modifier makes it part of the schema and generated code.

The Full Feature Set​

Nullable Fields with optional​

message Profile {
    string username = 1;          // Non-optional
    optional string bio = 2;     // Nullable
    optional Address home = 3;   // Nullable struct
}
LanguageNon-optionalOptional
JavaString usernameString bio (nullable)
Pythonusername: strbio: Optional[str]
GoUsername stringBio *string
Rustusername: Stringbio: Option<String>
C++std::stringstd::optional<std::string>
C#string Usernamestring? Bio
Swiftvar username: Stringvar bio: String?

Nested Types​

message SearchResponse {
    message Result {
        string url = 1;
        string title = 2;
        list<string> snippets = 3;
    }
    list<Result> results = 1;
}

Nested types are rendered naturally in each language: SearchResponse.Result in Java/Python/C#/Swift, SearchResponse::Result in C++, search_response::Result in Rust, SearchResponse_Result in Go.

Imports for Multi-File Schemas​

// common/types.fdl
package common;
message Address {
    string street = 1;
    string city = 2;
}

// models/user.fdl
package models;
import "common/types.fdl";

message User {
    string name = 1;
    Address home = 2;  // Uses imported type
}
foryc models/user.fdl -I common/ --java_out=./gen

The compiler resolves imports, catches import cycles, and keeps generated type registration consistent across imported schemas.

Language-Specific Options​

Override output paths and naming conventions per language without affecting cross-language compatibility:

package payment;
option java_package = "com.mycorp.payment.v1";
option go_package = "github.com/mycorp/gen/payment;paymentv1";
option csharp_namespace = "MyCorp.Payment.V1";

These options control where code is generated and how host-language names are shaped — not the underlying Fory wire format or cross-language type identity.

Rich Type System​

Fory IDL covers the full range of types you need for production schemas:

CategoryTypes
Integersint8, int16, int32, int64, uint8–uint64, fixed_*, tagged_*
Floatsfloat32, float64
Stringsstring, bytes
Temporaldate, timestamp, duration
Specialdecimal, any, bool
Collectionslist<T>, map<K, V>
Modifiersoptional, ref, ref(weak=true)

Integer types use varint encoding by default for 32/64-bit values, with explicit fixed_* and tagged_* variants when you need specific encodings.

Migrating from Protobuf or FlatBuffers​

Protobuf Migration​

Already have .proto schemas? The Fory compiler can read them directly and generate Fory code from them:

foryc existing_schema.proto --java_out=./gen --python_out=./gen

The output uses Fory-generated types and the Fory binary protocol. Reading .proto input does not mean protobuf wire compatibility.

Key mapping:

  • repeated T → list<T>
  • oneof → Fory union + optional field
  • google.protobuf.Timestamp → timestamp
  • google.protobuf.Any → any

You can also add Fory-specific extensions in your .proto files:

message TreeNode {
  TreeNode parent = 1 [(fory).weak_ref = true];
  repeated TreeNode children = 2 [(fory).ref = true];
}

FlatBuffers Migration​

FlatBuffers schemas work too:

foryc existing_schema.fbs --lang java,python,go --output ./gen

Tables become evolving messages, structs become non-evolving messages, and unions map directly to Fory unions. As with protobuf input, the generated output uses Fory types and Fory wire format rather than FlatBuffers binary compatibility. Add fory_ref:true or fory_weak_ref:true attributes where graph semantics matter.

Inspect the Translation​

See exactly how your protobuf/FlatBuffers schema maps to Fory IDL:

foryc schema.proto --emit-fdl

This prints the translated .fdl to stdout — useful for reviewing the mapping before committing to the migration.

Why Not Just Use Protobuf?​

A direct comparison with Protocol Buffers is useful because it is the default reference point for many readers.

AspectProtocol BuffersFory IDL
Generated typesTransport-model-first in many languagesIdiomatic language constructs
Object graphsApplication-level IDs / rebuildsFirst-class ref / ref(weak=true)
Circular referencesNot built-inBuilt into generated schemas
Variant fieldsoneof / Anyunion / any in the generated model
PerformanceMature baselineOften faster on object serialization workloads
gRPC ecosystemNative, matureIn progress (active development)
Schema evolutionField numbers + wire typesCompatible mode for generated schemas with field-id matching
Target languagesMany (via plugins)Java, Python, Go, Rust, C++, C#, Swift (and growing)

Use protobuf when gRPC ecosystem integration is your primary concern. Use Fory IDL when you need idiomatic domain objects, object-graph semantics, reference tracking, or maximum serialization performance.

Benchmark details and methodology live in the repository's benchmark reports.

Build Integration​

The Fory compiler integrates into every major build system. Below are examples for a few common ones — the same pattern (invoke foryc as a pre-build step) applies to Cargo build scripts, Bazel rules, CMake custom commands, Swift Package Manager plugins, and others:

Maven (Java):

<execution>
  <id>generate-fory-types</id>
  <phase>generate-sources</phase>
  <goals><goal>exec</goal></goals>
  <configuration>
    <executable>foryc</executable>
    <arguments>
      <argument>${basedir}/src/main/fdl/schema.fdl</argument>
      <argument>--java_out</argument>
      <argument>${project.build.directory}/generated-sources/fory</argument>
    </arguments>
  </configuration>
</execution>

Gradle (Kotlin/Java):

task generateForyTypes(type: Exec) {
    commandLine 'foryc', "${projectDir}/src/main/fdl/schema.fdl",
        '--java_out', "${buildDir}/generated/sources/fory"
}
compileJava.dependsOn generateForyTypes

Go Generate:

//go:generate foryc ../schema.fdl --lang go --output .
package models

Python (setuptools):

class BuildWithForyIdl(build_py):
    def run(self):
        subprocess.run(['foryc', 'schema.fdl', '--python_out', 'src/generated'], check=True)
        super().run()

Best Practices​

  1. Use meaningful package names: com.myapp.models groups types logically and drives namespace generation.

  2. Use optional explicitly: Don't rely on default nullability — make the intent clear in the schema.

  3. Use ref only when needed: Reference tracking has a per-object cost. Use it for shared objects and cycles; skip it for value-type payloads.

  4. Use imports for shared types: Put common types (Address, Timestamp, etc.) in a shared .fdl file and import them.

  5. Use --emit-fdl to review migrations: When consuming .proto or .fbs input, inspect the translated Fory IDL before committing.

Conclusion​

Apache Fory Schema IDL puts object-graph semantics into the schema model instead of leaving them to ad-hoc application code. If you need shared refs, circular structures, polymorphic fields, schema evolution, and generated models that still look idiomatic in each language, it gives you one schema and one compiler workflow for all of that.

Define your types once. Generate everywhere. Serialize object graphs without giving up idiomatic models.

Get started:

pip install fory-compiler
foryc --help

Documentation:

Community:

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Introducing Apache Fory™ C++: Blazing-Fast, Type-Safe Serialization for Modern C++]]> https://fory.apache.org/blog/fory_cpp_blazing_fast_serialization_framework 2026-02-19T00:00:00.000Z TL;DR: Apache Fory C++ is a blazing-fast, cross-language serialization framework delivering exceptional binary performance with support for polymorphic types, circular references, schema evolution, and seamless interoperability with Java, Python, Go, Rust, and JavaScript — all via modern C++17 with zero runtime reflection overhead.

The C++ Serialization Problem​

Every C++ developer working in a polyglot environment eventually hits the same wall. Existing options force a painful choice:

  1. IDL-first frameworks (Protocol Buffers, FlatBuffers): Require upfront schema compilation, lose native C++ type expressiveness, and carry significant integration friction. Every type change means regenerating code across all languages in lock-step.
  2. Reflection-based frameworks (Boost.Serialization, cereal): Limited cross-language support, no circular reference handling, no polymorphism without boilerplate. They work well within a single language but break down at system boundaries.
  3. Hand-rolled binary formats: Fast but brittle — any schema change risks silent corruption, and every new type requires manual encode/decode logic.

Apache Fory C++ eliminates this trade-off. It delivers performance competitive with the fastest C++ serialization libraries while providing first-class support for polymorphism, shared/circular references, schema evolution, and binary compatibility with Java, Python, Go, Rust, and JavaScript — through a clean C++17 API.

What Makes Apache Fory C++ Different?​

Compile-Time Code Generation​

Most serialization frameworks pay a runtime cost for flexibility — inspecting type information through virtual dispatch or hash maps at every call. Apache Fory takes a different approach: the FORY_STRUCT macro uses C++ template metaprogramming to generate all serialization logic at compile time. The result is inlined, type-specific code with no virtual dispatch, no reflection, and no runtime overhead:

#include "fory/serialization/fory.h"
using namespace fory::serialization;

struct Person {
  std::string name;
  int32_t age;
  std::vector<std::string> hobbies;
  std::map<std::string, std::string> metadata;
  std::optional<std::string> nickname;
};
FORY_STRUCT(Person, name, age, hobbies, metadata, nickname);

That single macro generates compile-time field metadata, efficient serialization/deserialization code via ADL (Argument-Dependent Lookup), and type registration hooks. The macro can be placed inside the class body to access private fields, or at namespace scope for third-party types.

Cross-Language Binary Protocol​

Apache Fory C++ speaks the same binary wire format as Java, Python, Go, Rust, and JavaScript. Serialize a struct in C++, deserialize it in Python — no adaptation layer, no schema translation, no version negotiation needed. This is especially powerful for microservice architectures where different teams own different services in different languages:

// C++: Serialize
auto fory = Fory::builder().xlang(true).build();
fory.register_struct<Person>(100);
auto bytes = fory.serialize(person).value();
# Python: Deserialize (same binary format, same type ID)
fory = pyfory.Fory(xlang=True)
fory.register(Person, type_id=100)  # Same ID as C++
person = fory.deserialize(data)

The core requirements for cross-language interoperability are consistent type IDs/Names across participating runtimes, matching canonical field names, and compatible field types for those names.

Polymorphism via Smart Pointers​

Serializing polymorphic objects is notoriously difficult in C++. Most frameworks require manual type tagging or generate large amounts of boilerplate. Apache Fory handles it automatically: it detects polymorphic types via std::is_polymorphic<T> and preserves the full runtime type identity through std::shared_ptr and std::unique_ptr. When you deserialize a shared_ptr<Animal> that holds a Dog, you get a Dog back — no extra code required:

struct Animal { virtual ~Animal() = default; int32_t age = 0; };
FORY_STRUCT(Animal, age);
struct Dog : Animal { std::string breed; };
FORY_STRUCT(Dog, FORY_BASE(Animal), breed);
struct Cat : Animal { std::string color; };
FORY_STRUCT(Cat, FORY_BASE(Animal), color);

struct Shelter { std::vector<std::shared_ptr<Animal>> animals; };
FORY_STRUCT(Shelter, animals);

auto fory = Fory::builder().track_ref(true).build();
fory.register_struct<Shelter>(10); fory.register_struct<Dog>(11); fory.register_struct<Cat>(12);

Shelter s;
s.animals.push_back(std::make_shared<Dog>()); // Dog at runtime
s.animals.push_back(std::make_shared<Cat>()); // Cat at runtime

auto decoded = fory.deserialize<Shelter>(fory.serialize(s).value()).value();
assert(dynamic_cast<Dog*>(decoded.animals[0].get()) != nullptr); // Runtime type preserved!

Fory also supports std::unique_ptr for exclusive-ownership polymorphic fields, and collections of smart pointers (std::vector<std::shared_ptr<Base>>, std::map<K, std::unique_ptr<Base>>).

Shared/Circular Reference Tracking​

Many real-world data models contain shared objects or cycles: a parent node pointing to its children, which point back to the parent; an order referencing a customer who appears in multiple orders. Standard serialization frameworks either duplicate the data (wasting space) or crash with a stack overflow when they encounter a cycle.

With track_ref(true), Fory tracks object identity across the entire graph. Shared objects are serialized exactly once; every subsequent reference is encoded as a back-reference. Cycles terminate naturally:

struct Node {
  virtual ~Node() = default;
  int32_t id = 0;
  std::vector<std::shared_ptr<Node>> neighbors;
};
FORY_STRUCT(Node, id, neighbors);

auto fory = Fory::builder().track_ref(true).build();
fory.register_struct<Node>(200);

auto node1 = std::make_shared<Node>(); node1->id = 1;
auto node2 = std::make_shared<Node>(); node2->id = 2;
node1->neighbors.push_back(node2);
node2->neighbors.push_back(node1);  // Cycle — handled correctly!

auto bytes = fory.serialize(node1).value();
// No stack overflow, no duplicate data — the cycle is preserved faithfully
auto decoded = fory.deserialize<std::shared_ptr<Node>>(bytes).value();

This makes Fory a natural fit for graph databases, entity-component systems, and any domain model with bidirectional relationships.

Schema Evolution​

In a microservice deployment, services update independently. A new version of the user service may add a phone field while old consumers are still running. Without schema evolution support, this forces a coordinated, big-bang deployment. Apache Fory's compatible mode removes this constraint entirely:

// Version 1
struct UserV1 { std::string name; int32_t age; };
FORY_STRUCT(UserV1, name, age);

// Version 2 — new fields added independently
struct UserV2 { std::string name; int32_t age; std::string email; };
FORY_STRUCT(UserV2, name, age, email);

auto fory_v1 = Fory::builder().compatible(true).xlang(true).build();
auto fory_v2 = Fory::builder().compatible(true).xlang(true).build();
fory_v1.register_struct<UserV1>(100);
fory_v2.register_struct<UserV2>(100);  // Same type ID enables evolution

auto bytes = fory_v1.serialize(UserV1{"Alice", 30}).value();
auto v2 = fory_v2.deserialize<UserV2>(bytes).value();
assert(v2.name == "Alice" && v2.email == "");  // Default for missing field

In compatible mode, fields are matched by name rather than position. New fields receive C++ default values when missing; removed fields are safely skipped. This enables rolling upgrades and independent service deployments without any serialization errors.

Row Format: Zero-Copy Analytics​

Beyond object graph serialization, Apache Fory C++ implements a row-based binary format designed for analytics workloads. The row format stores data in a contiguous memory layout with a null bitmap, fixed-size slots for primitives, and a variable-length section for strings and nested objects. This enables O(1) random field access by index — you can read a single field from a large struct without touching the rest of the data.

This is particularly valuable in data pipelines and OLAP workloads where only a small subset of fields are queried per record:

#include "fory/encoder/row_encoder.h"
using namespace fory::row::encoder;

struct SensorReading {
  int32_t sensor_id; double temperature; std::string location;
  FORY_STRUCT(SensorReading, sensor_id, temperature, location);
};

RowEncoder<SensorReading> encoder;
encoder.encode({42, 23.5, "rack-B"});
auto row = encoder.get_writer().to_row();

// Read any field in O(1) — no deserialization of unused fields
int32_t id    = row->get_int32(0);
double  temp  = row->get_double(1);
auto    loc   = row->get_string(2);

For zero-copy access into an existing buffer (e.g., from a memory-mapped file or network receive buffer), Fory can point a Row directly at the memory without copying:

auto src = encoder.get_writer().to_row();
fory::row::Row view(src->schema());
view.point_to(src->buffer(), src->base_offset(), src->size_bytes());  // Zero-copy view
int32_t id = view.get_int32(0);  // Reads directly from the original buffer

Use the row format for analytics, OLAP-style workloads, and partial field access. Use object graph serialization for full object round-trips with references and polymorphism.

Installation​

Fory C++ requires a C++17-compatible compiler (GCC 7+, Clang 5+, MSVC 2017+) and supports both CMake and Bazel build systems.

CMake (FetchContent)​

The simplest integration is via CMake's FetchContent module, which fetches and builds Fory as part of your project:

cmake_minimum_required(VERSION 3.16)
project(my_project LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 17)

include(FetchContent)
FetchContent_Declare(fory
    GIT_REPOSITORY https://github.com/apache/fory.git
    GIT_TAG v0.15.0
    SOURCE_SUBDIR cpp)
FetchContent_MakeAvailable(fory)

add_executable(my_app main.cc)
target_link_libraries(my_app PRIVATE fory::serialization)

Bazel​

For Bazel-based projects, add Fory as a module dependency:

bazel_dep(name = "fory", version = "0.15.0")
git_override(module_name = "fory",
    remote = "https://github.com/apache/fory.git",
    commit = "v0.15.0")
cc_binary(name = "my_app", srcs = ["main.cc"],
    deps = ["@fory//cpp/fory/serialization:fory_serialization"])

Native Serialization​

For pure C++ applications without cross-language requirements, disabling xlang produces a more compact binary encoding because no cross-language type metadata is emitted. This is the fastest possible path:

auto fory = Fory::builder()
    .xlang(false)      // Native C++ mode — tighter encoding
    .track_ref(false)  // Disable if no shared/circular refs
    .build();

fory.register_struct<Address>(1);
fory.register_struct<Person>(2);

// Serialize
auto result = fory.serialize(person);
if (!result.ok()) { std::cerr << result.error().to_string(); return 1; }
std::vector<uint8_t> bytes = std::move(result).value();

// Deserialize
auto decoded = fory.deserialize<Person>(bytes);
assert(decoded.ok() && person == decoded.value());

FORY_STRUCT handles several important C++ patterns that commonly arise in production codebases:

// Private fields — place macro in public: section
class Secure {
  int32_t secret_; std::string token_;
public:
  FORY_STRUCT(Secure, secret_, token_);
};

// Inheritance — FORY_BASE includes base class fields
struct Derived : Base {
  std::string extra;
  FORY_STRUCT(Derived, FORY_BASE(Base), extra);
};

// External/third-party types — use at namespace scope (public fields only)
namespace ext { struct Coord { double lat, lon; }; }
FORY_STRUCT(ext::Coord, lat, lon);

Error Handling​

All Fory operations return Result<T, Error>, making error handling explicit and composable. The FORY_TRY macro provides a concise early-return pattern for functions that propagate errors:

// Option 1: Conditional check
auto r = fory.serialize(obj);
if (r.ok()) { auto bytes = std::move(r).value(); }
else { std::cerr << r.error().to_string(); }

// Option 2: FORY_TRY macro for early return
FORY_TRY(bytes, fory.serialize(obj));
// Use bytes directly — any error propagates automatically

Thread Safety​

Fory provides two variants with different threading guarantees. Choose based on whether your serialization is centralized (shared instance) or distributed across threads:

// Single-threaded (fastest) — one instance per thread, no synchronization overhead
auto fory = Fory::builder().build();

// Thread-safe — shared across threads via an internal instance pool
auto fory = Fory::builder().build_thread_safe();
fory.register_struct<MyType>(1);  // Register all types before sharing
std::thread t([&]() { fory.serialize(obj); });  // Safe to call concurrently

Cross-Language Serialization​

Without IDL​

When you control both sides of the wire and can coordinate type definitions manually, the simplest approach is to register types with matching numeric IDs in each language. This requires no additional tooling and works well for small, stable schemas:

// C++
auto fory = Fory::builder().xlang(true).build();
fory.register_struct<Order>(201);
auto bytes = fory.serialize(order).value();
// Java — same binary format, same type ID
Fory fory = Fory.builder().withLanguage(Language.XLANG).build();
fory.register(Order.class, 201);
Order order = (Order) fory.deserialize(bytes);
# Python — same binary format, same type ID
fory = pyfory.Fory(xlang=True)
fory.register(Order, type_id=201)
order = fory.deserialize(data)

Field matching: In cross-language mode, field names are normalized to snake_case and matched by that canonical name. Ordering follows Fory's xlang field-order rules (not simple alphabetical ordering), so keep names semantically consistent across languages.

With the Fory Schema IDL Compiler​

As schemas grow and span more services and teams, manually maintaining consistent field names, type IDs, and type definitions across five languages becomes error-prone. The Fory Schema IDL Compiler (foryc) solves this by letting you define types once in a .fdl file and generating idiomatic, production-ready code for every target language. The generated code includes typed accessors, serialization macros, registration helpers, and to_bytes()/from_bytes() helpers — so you never write serialization plumbing by hand.

1. Install the compiler​

pip install fory-compiler
foryc --help

2. Write a schema (ecommerce.fdl)​

Fory IDL syntax is concise and deliberately close to protobuf, so it is easy to pick up. Field modifiers like optional, ref, and list map directly to idiomatic C++ types:

package ecommerce;

enum OrderStatus {
    PENDING = 0; CONFIRMED = 1; SHIPPED = 2; DELIVERED = 3;
}

message Address {
    string street = 1; string city = 2; string country = 3;
}

message Customer {
    string           id      = 1;
    string           name    = 2;
    optional string  email   = 3;   // Nullable: maps to std::optional<std::string>
    optional Address address = 4;
}

message OrderItem {
    string  sku        = 1;
    int32   quantity   = 2;
    float64 unit_price = 3;
}

// Discount can be either a fixed amount or a percentage — modelled as a union
message FixedDiscount   { float64 amount     = 1; }
message PercentDiscount { float64 percentage = 1; }

// union maps to std::variant<FixedDiscount, PercentDiscount> in C++
union Discount {
    FixedDiscount   fixed   = 1;
    PercentDiscount percent = 2;
}

message Order {
    string            order_id   = 1;
    ref Customer      customer   = 2;  // ref: std::shared_ptr + reference tracking
    list<OrderItem>   items      = 3;  // list: std::vector<OrderItem>
    OrderStatus       status     = 4;
    float64           total      = 5;
    optional string   notes      = 6;
    timestamp         created_at = 7;
    optional Discount discount   = 8;  // optional union field
}

The IDL type system maps cleanly to native C++ constructs. union is a first-class IDL construct that generates a std::variant-based wrapper class in C++, with typed case accessors (is_fixed(), as_fixed(), etc.) and a visit() method. Here is the full set of field modifiers and their C++ equivalents:

ModifierC++ typePurpose
optional Tstd::optional<T>Nullable field
ref Tstd::shared_ptr<T>Shared / circular reference
ref(weak=true) Tfory::serialization::SharedWeak<T>Weak reference (breaks cycles)
list<T>std::vector<T>Ordered list
map<K,V>std::map<K,V>Key-value map

3. Generate code​

foryc generates a single header file per schema for C++, and equivalent files for every other target language. All generated files use the same type IDs derived from the package and type names, guaranteeing binary compatibility without any manual coordination:

# Generate C++ header directly under ./generated
foryc ecommerce.fdl --cpp_out ./generated

# Generate multiple languages with explicit output directories
foryc ecommerce.fdl --cpp_out ./generated --java_out ./java/src/main/java --python_out ./python/gen --go_out ./go/gen --rust_out ./rust/gen

The output structure for C++ is one header per schema file under the directory passed to --cpp_out. For example, --cpp_out ./generated produces generated/ecommerce.h. The header contains all types under the ecommerce:: namespace, with FORY_STRUCT macros and a register_types() helper already wired up.

4. Use the generated C++ code​

The generated header provides final classes with typed accessors and to_bytes()/from_bytes() helpers. There is no manual Fory instance setup required — the helpers manage it internally:

#include "generated/ecommerce.h"

ecommerce::Order order;
order.set_order_id("ORD-2025-001");
order.mutable_customer()->set_name("Alice");
order.set_status(ecommerce::OrderStatus::CONFIRMED);
order.set_total(159.98);

// to_bytes()/from_bytes() are generated — no Fory boilerplate needed
auto bytes = order.to_bytes().value();
auto restored = ecommerce::Order::from_bytes(bytes).value();
assert(restored.order_id() == "ORD-2025-001");

Because the generated Java, Python, and Go code uses the same type IDs, bytes serialized by the C++ to_bytes() helper can be deserialized by the Java fromBytes() or Python from_bytes() helpers out of the box — no extra configuration required.

Supported Types​

Apache Fory C++ supports a comprehensive set of types covering all common C++ data structures and cross-language primitives:

CategoryC++ Types
Primitivesbool, int8_t…int64_t, uint8_t…uint64_t, float, double
Stringsstd::string, std::string_view, std::u16string
Collectionsstd::vector<T>, std::set<T>, std::unordered_set<T>, std::map<K,V>, std::unordered_map<K,V>
Optional/Unionstd::optional<T>, std::variant<Ts...>
Smart Pointersstd::shared_ptr<T> (ref tracking + polymorphism), std::unique_ptr<T>, fory::serialization::SharedWeak<T>
Temporalstd::chrono::nanoseconds, fory::serialization::Timestamp, fory::serialization::Date
EnumsScoped/unscoped enums; use FORY_ENUM for non-continuous values
User structsAny type annotated with FORY_STRUCT

All collection element and map value types can be arbitrarily nested, including structs, smart pointers, and std::optional.

Configuration Reference​

Fory instances are constructed through a fluent builder API. All options have sensible defaults, so most applications only need to set one or two:

auto fory = Fory::builder()
    .xlang(true)                // Cross-language binary protocol (default: true)
    .compatible(true)           // Schema evolution / compatible mode (default: false)
    .track_ref(true)            // Shared/circular reference tracking (default: true)
    .max_dyn_depth(10)          // Max polymorphic nesting depth (default: 5)
    .check_struct_version(true) // Validate struct hash on deserialization (default: false)
    .build();                   // Single-threaded; use build_thread_safe() for multi-thread

Tuning guide: Disable compatible for maximum throughput when schema changes are coordinated (same binary deployed together). Disable track_ref for pure value types with no sharing or cycles — it eliminates per-object reference bookkeeping. Use xlang(false) for C++-only deployments to get a more compact binary encoding.

Benchmarks​

Apache Fory delivers exceptional performance across diverse data shapes. The combination of compile-time code generation, variable-length integer encoding, and a carefully designed binary protocol yields major gains versus text formats and strong results versus Protocol Buffers. In the current C++ benchmark report, Fory throughput vs Protobuf ranges from about 1.1x to 12.2x depending on workload and operation:

The C++ implementation achieves similar relative speedups to the Java implementation. Because both share the same binary protocol design, and C++ serialization code is generated at compile time (eliminating the JIT warm-up cost), C++ performance is competitive or superior for latency-sensitive workloads.

Serialized Data Sizes (bytes)

DatatypeForyProtobuf
Struct5861
Sample446375
MediaContent365301
StructList184315
SampleList19801890
MediaContentList15351520

Conclusion​

Apache Fory C++ brings together a set of capabilities that no other C++ serialization library delivers as a cohesive package:

  • Performance: Template-based compile-time codegen eliminates all runtime reflection overhead; a highly efficient binary protocol minimizes both serialized size and CPU cycles
  • Cross-language: The same binary format works natively with Java, Python, Go, Rust, and JavaScript
  • Native C++ idioms: std::shared_ptr, std::optional, std::variant, fory::serialization::SharedWeak — all handled naturally
  • Production-ready features: Polymorphism, circular references, schema evolution, thread safety out of the box
  • Schema-first option: The Fory IDL Compiler generates consistent, idiomatic code across all languages from a single .fdl definition — no more manually synchronizing type IDs across codebases

Whether you are building a high-performance game server, a polyglot microservice backend, a real-time analytics pipeline, or an embedded system serializing complex domain models, Apache Fory C++ has you covered.

Get started:

git clone https://github.com/apache/fory.git
cd fory/examples/cpp/hello_world
cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build
./build/hello_world

Documentation:

Community:

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.15.0 Released]]> https://fory.apache.org/blog/fory_0_15_0_release 2026-02-10T00:00:00.000Z The Apache Fory team is pleased to announce the 0.15.0 release. This is a major release that includes 144 PR from 17 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

Go Serialization: First Release​

Apache Fory 0.15.0 is the first release with official Go serialization support. The Go implementation delivers high-performance serialization with cross-language compatibility and production-focused configuration options.

Key capabilities:

  • Cross-language mode with Java, Python, cpp, Rust, and JavaScript (fory.WithXlang(true))
  • Reflection-based serialization by default, plus optional experimental AOT code generation for hot paths
  • Reference tracking for shared/circular object graphs (fory.WithTrackRef(true) + fory:"ref" tags)
  • Compatible mode for schema evolution (fory.WithCompatible(true)) supporting add/remove/reorder field changes
  • Thread-safe wrapper (github.com/apache/fory/go/fory/threadsafe) for concurrent workloads

Quick Start​

package main

import (
    "github.com/apache/fory/go/fory"
)

type User struct {
    ID   int64
    Name string
}

func main() {
    f := fory.New(
        fory.WithXlang(true),
        fory.WithCompatible(true),
    )
    _ = f.RegisterStruct(User{}, 1)

    data, _ := f.Serialize(&User{ID: 1, Name: "Alice"})
    var out User
    _ = f.Deserialize(data, &out)
}

Go Benchmarks​

Below are timing results (ns/op; lower is better) comparing Fory with Protobuf and Msgpack across representative data structures.

Data TypeOperationForyProtobufMsgpack
StructSerialize66.097.8184.9
StructDeserialize82.790.9309.6
StructlistSerialize632.81783.03340.0
StructlistDeserialize906.41891.05709.0
SampleSerialize137.3367.31492.0
SampleDeserialize263.6422.22661.0
SamplelistSerialize1962.07087.026169.0
SamplelistDeserialize4234.09321.053615.0
MediacontentSerialize268.8471.1773.7
MediacontentDeserialize426.9553.11432.0
MediacontentlistSerialize3736.09107.013911.0
MediacontentlistDeserialize7247.011435.027975.0

Serialized data sizes (bytes):

Data TypeForyProtobufMsgpack
Struct586157
Sample446375524
MediaContent342301400
StructList56012601146
SampleList7600756010486
MediaContentList577660808006

Note: Results depend on hardware and implementation versions. See the Go benchmark docs for details: https://fory.apache.org/docs/benchmarks/go/

Fory Schema IDL and Compiler: First Release​

Apache Fory 0.15.0 also introduces the first release of the Fory schema IDL and compiler toolchain. You can define schemas once and generate native types and registration code across languages.

Key capabilities:

  • Schema-first development with enum, message, and union
  • Fory-native field semantics: optional (nullability), ref (shared/circular references), list, and map
  • Multi-language code generation for Java, Python, Go, Rust, and cpp
  • Protobuf (.proto) and FlatBuffers (.fbs) frontend support, translated into Fory IR/codegen
  • Idiomatic generated APIs with to/from bytes helpers

Quick Start​

pip install fory-compiler
foryc example.fdl --lang java,python,go,rust,cpp --output ./generated
package example;

message Person [id=101] {
    string name = 1;
    optional string email = 2;
}

Generated Code Example​

foryc generates idiomatic native types plus registration/byte helpers. For the schema above, generated code looks like:

// Go (excerpt)
type Person struct {
    Name  string                    `fory:"id=1"`
    Email optional.Optional[string] `fory:"id=2"`
}

func (m *Person) ToBytes() ([]byte, error)      { ... }
func (m *Person) FromBytes(data []byte) error   { ... }
func RegisterTypes(f *fory.Fory) error {
    return f.RegisterStruct(Person{}, 101)
}
// Java (excerpt)
public class Person {
    @ForyField(id = 1)
    private String name;

    @ForyField(id = 2, nullable = true)
    private String email;

    public byte[] toBytes() { ... }
    public static Person fromBytes(byte[] bytes) { ... }
}
# Python (excerpt)
@pyfory.dataclass
class Person:
    name: str = pyfory.field(id=1, default="")
    email: Optional[str] = pyfory.field(id=2, default=None)

    def to_bytes(self) -> bytes: ...
    @classmethod
    def from_bytes(cls, data: bytes) -> "Person": ...

Features​

Bug Fix​

Other Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.14.1...v0.15.0

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.14.1 Released]]> https://fory.apache.org/blog/fory_0_14_1_release 2025-12-26T00:00:00.000Z The Apache Fory team is pleased to announce the 0.14.1 release. This is a release that includes 6 PR from 5 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

Features​

Bug Fix​

Full Changelog: https://github.com/apache/fory/compare/v0.14.0...v0.14.1

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.14.0 Released]]> https://fory.apache.org/blog/fory_0_14_0_release 2025-12-15T00:00:00.000Z The Apache Fory team is pleased to announce the 0.14.0 release. This is a major release that includes 85 PR from 11 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

  • Official C++ Support: First release of Apache Fory C++ with high-performance object graph serialization, cross-language interoperability, and schema evolution
  • Row Format & Type System: New row-oriented format type system across Java, Python, and C++, enabling row-columnar conversions and removing Arrow dependencies
  • Performance Enhancements: Significant optimizations across all languages, including thread-local context in Rust and fast flat-int maps for C++ type dispatch
  • Ecosystem Updates: Added support for JDK 25 (Java), Go 1.23, and Bazel 8. Python officially marked as stable with improved build parallelism
  • Advanced Java Features: GraalVM Native Image support via ForyFeature and optimized serializers for blocking queues and final fields
  • ObjectStreamSerializer Refactoring: Refactored ObjectStreamSerializer with meta-shared compatible mode for reduced space cost and improved performance on JDK customized serialization APIs

C++: First Release Highlights​

This is the first Apache Fory C++ release, delivering a complete, high-performance serialization framework for modern C++17. If you build C++ applications requiring fast serialization, cross-language communication, or schema evolution, Fory C++ provides type-safe, compile-time serialization with minimal overhead.

Key capabilities:

  • Macro-based struct registration via FORY_STRUCT for compile-time type safety
  • Cross-language serialization with Java, Python, Go, Rust, and JavaScript
  • Forward/backward compatible schema evolution (Compatible mode)
  • Reference tracking for shared objects and circular references
  • Thread-safe and single-threaded (fastest) variants
  • Comprehensive type support: primitives, std::string, std::vector, std::map, std::set, std::optional, std::shared_ptr, std::unique_ptr, std::variant, and temporal types
  • Zero-copy Row format for analytics workloads with random field access
  • CMake (FetchContent) and Bazel build system support

Quick Start​

#include "fory/serialization/fory.h"

using namespace fory::serialization;

struct Person {
  std::string name;
  int32_t age;
  std::vector<std::string> hobbies;
  FORY_STRUCT(Person, name, age, hobbies);
};

int main() {
  auto fory = Fory::builder()
      .xlang(true)       // Enable cross-language mode
      .track_ref(false)  // Disable ref tracking for simple types
      .build();
  fory.register_struct<Person>(1);

  Person person{"Alice", 30, {"reading", "coding"}};
  auto bytes = fory.serialize(person).value();
  Person decoded = fory.deserialize<Person>(bytes).value();
  // person == decoded
  return 0;
}

C++ Benchmarks​

Below are timing results (nanoseconds; lower is better) comparing Fory with Protobuf across different data structures.

DatatypeOperationFory (ns)Protobuf (ns)Faster
MediaContentSerialize4142,046Fory (4.9x)
MediaContentDeserialize1,3612,890Fory (2.1x)
SampleSerialize210307Fory (1.5x)
SampleDeserialize1,0611,500Fory (1.4x)
StructSerialize51181Fory (3.5x)
StructDeserialize136170Fory (1.3x)

Note: Results depend on hardware and implementation versions. See the C++ benchmark guide for how to run benchmarks yourself: https://github.com/apache/fory/tree/main/benchmarks/cpp_benchmark

Features​

Bug Fix​

Other Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.13.2...v0.14.0

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.13.2 Released]]> https://fory.apache.org/blog/fory_0_13_2_release 2025-12-05T00:00:00.000Z The Apache Fory team is pleased to announce the 0.13.2 release. This is a release that includes 25 PR from 4 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

Features​

Bug Fix​

Other Improvements​

Full Changelog: https://github.com/apache/fory/compare/v0.13.1...v0.13.2

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.13.1 Released]]> https://fory.apache.org/blog/fory_0_13_1_release 2025-11-06T00:00:00.000Z The Apache Fory team is pleased to announce the 0.13.1 release. This is a release that includes 28 PR from 11 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

  • Support rust enum variant and schema evolution for tuple/struct style enum
  • Support rust tuple serialization and schema evolution
  • Support rust skip macro attributes

Enum Schema Evolution​

Fory v0.13.1 adds comprehensive enum schema evolution in Compatible mode, supporting all three variant types (Unit, Unnamed, Named):

  • Add/remove variants: Unknown variants fall back to #[fory(default)]
  • Add/remove fields: Named variants support field evolution with automatic defaults
  • Modify elements: Unnamed variants handle element count changes (extras skipped, missing use defaults)
  • Variant type changes: Convert between Unit/Unnamed/Named with automatic default values
// Version 1
#[derive(ForyObject)]
enum Command {
    #[fory(default)]
    Noop,
    Execute { name: String, args: i32 },
}

// Version 2 - Added field and new variant
// both `fory(default)` and standard `default` are supported
#[derive(Default, ForyObject)]
enum Command {
    #[default]
    Noop,
    Execute { name: String, args: i32, env: String },  // Added 'env'
    Cancel { reason: String },  // New variant
}

// V1→V2: Missing 'env' gets default ""; Cancel→Noop fallback in V1
// V2→V1: Extra 'env' skipped; Cancel→Noop fallback

Tuple Schema Evolution​

Tuples (1-22 elements) now support length evolution in Compatible mode:

  • Length changes: Grow or shrink tuple size (missing elements get defaults, extras discarded)
  • Collections: Vec, HashMap, HashSet elements fully supported
  • Nested tuples: Multi-level nesting with independent evolution per level
  • Smart pointers: Option, Arc, Rc wrapped elements handle evolution correctly
  • Struct fields: Tuple fields in structs evolve independently
let fory = Fory::default().compatible(true);

// Serialize 2-element tuple
let short = (42i32, "hello".to_string());
let bin = fory.serialize(&short).unwrap();

// Deserialize as 4-element tuple - extras get defaults
let long: (i32, String, f64, bool) = fory.deserialize(&bin).unwrap();
assert_eq!(long, (42, "hello".to_string(), 0.0, false));

// Reverse: 4→2 elements, extras discarded
let long = (100i32, "world".to_string(), 3.14, true);
let bin = fory.serialize(&long).unwrap();
let short: (i32, String) = fory.deserialize(&bin).unwrap();
assert_eq!(short, (100, "world".to_string()));

Features​

Bug Fix​

Other Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.13.0...v0.13.1

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Introducing Apache Fory™ Rust: A Versatile Serialization Framework for the Modern Age]]> https://fory.apache.org/blog/fory_rust_versatile_serialization_framework 2025-10-29T00:00:00.000Z TL;DR: Apache Fory Rust is a blazingly-fast, cross-language serialization framework that delivers ultra-fast serialization performance while automatically handling circular references, trait objects, and schema evolution. Built with Rust's safety guarantees and zero-copy techniques, it's designed for developers who refuse to compromise between performance and developer experience.

The Serialization Dilemma​

Every backend engineer has faced this moment: your application needs to serialize complex data structures such as nested objects, circular references, polymorphic types, and you're forced to choose between three bad options:

  1. Fast but fragile: Hand-rolled binary formats that break with schema changes
  2. Flexible but slow: JSON/Protocol with 10x performance overhead
  3. Complex and limiting: Existing solutions that don't support your language's advanced features

Apache Fory Rust eliminates this false choice. It's a serialization framework that delivers exceptional performance while automatically handling the complexities of modern applications—no IDL files, no manual schema management, no compromises.

What Makes Apache Fory Rust Different?​

1. Truly Cross-Language​

Apache Fory Rust speaks the same binary protocol as Java, Python, C++, Go, and other language implementations. Serialize data in Rust, deserialize in Python — it just works. No schema files. No code generation. No version mismatches.

// Rust: Serialize
let user = User {
    name: "Alice".to_string(),
    age: 30,
    metadata: HashMap::from([("role", "admin")]),
};
let bytes = fory.serialize(&user);

// Python: Deserialize (same binary format!)
user = fory.deserialize(bytes)  # Just works!

This isn't just convenient — it changes how we develop microservices architectures where different teams use different languages.

2. Automatic Shared/Circular Reference Handling​

Most serialization frameworks panic when encountering circular references. Apache Fory tracks and preserves reference identity automatically:

Shared Reference:

use fory::Fory;
use std::rc::Rc;

let fory = Fory::default();

// Create a shared value
let shared = Rc::new(String::from("shared_value"));

// Reference it multiple times
let data = vec![shared.clone(), shared.clone(), shared.clone()];

// The shared value is serialized only once
let bytes = fory.serialize(&data);
let decoded: Vec<Rc<String>> = fory.deserialize(&bytes)?;

// Verify reference identity is preserved
assert_eq!(decoded.len(), 3);
assert_eq!(*decoded[0], "shared_value");

// All three Rc pointers point to the same object
assert!(Rc::ptr_eq(&decoded[0], &decoded[1]));
assert!(Rc::ptr_eq(&decoded[1], &decoded[2]));

Circular Reference:

use fory::{ForyObject, RcWeak};

#[derive(ForyObject)]
struct Node {
    value: i32,
    parent: RcWeak<RefCell<Node>>,     // Weak pointer breaks cycles
    children: Vec<Rc<RefCell<Node>>>,  // Strong references tracked
}

// Build a parent-child tree with circular references
let parent = Rc::new(RefCell::new(Node { ... }));
let child = Rc::new(RefCell::new(Node {
    parent: RcWeak::from(&parent),  // Points back to parent
    ...
}));
parent.borrow_mut().children.push(child.clone());

// Serialization handles the cycle automatically
let bytes = fory.serialize(&parent);
let decoded: Rc<RefCell<Node>> = fory.deserialize(&bytes)?;

// Reference relationships preserved!
assert!(Rc::ptr_eq(&decoded, &decoded.borrow().children[0].borrow().parent.upgrade().unwrap()));

This isn't just a feature—it's essential for graph databases, object-relational mappers, and domain models.

3. Trait Object Serialization​

Rust's trait system enables powerful abstractions, but serializing Box<dyn Trait> is notoriously difficult. Apache Fory makes it trivial:

use fory::{ForyObject, Serializer, register_trait_type};

trait Animal: Serializer {
    fn speak(&self) -> String;
}

#[derive(ForyObject)]
struct Dog { name: String, breed: String }

#[derive(ForyObject)]
struct Cat { name: String, color: String }

// Register implementations
register_trait_type!(Animal, Dog, Cat);

// Serialize heterogeneous collections
let animals: Vec<Box<dyn Animal>> = vec![
    Box::new(Dog { ... }),
    Box::new(Cat { ... }),
];

let bytes = fory.serialize(&animals);
let decoded: Vec<Box<dyn Animal>> = fory.deserialize(&bytes)?;

// Polymorphism preserved!
decoded[0].speak();  // "Woof!"
decoded[1].speak();  // "Meow!"

Alternative: Using dyn Any without trait registration:

use std::rc::Rc;
use std::any::Any;

// No trait definition or registration needed
let dog: Rc<dyn Any> = Rc::new(Dog { name: "Rex".to_string(), breed: "Labrador".to_string() });
let cat: Rc<dyn Any> = Rc::new(Cat { name: "Whiskers".to_string(), color: "Orange".to_string() });

let bytes = fory.serialize(&dog);
let decoded: Rc<dyn Any> = fory.deserialize(&bytes)?;

// Downcast to concrete type
let unwrapped = decoded.downcast_ref::<Dog>().unwrap();
assert_eq!(unwrapped.name, "Rex");

Supports:

  • Box<dyn Trait> - Owned trait objects
  • Rc<dyn Trait> / Arc<dyn Trait> - Reference-counted trait objects
  • Rc<dyn Any> / Arc<dyn Any> - Runtime type dispatch without traits
  • Auto-generated wrapper types for standalone serialization

This unlocks plugin systems, heterogeneous collections, and extensible architectures that were previously impossible to serialize.

4. Schema Evolution Without Breaking Changes​

Microservices evolve independently. Apache Fory's Compatible mode allows schema changes without coordination:

use fory::{Fory, ForyObject};

// Service A: Version 1
#[derive(ForyObject)]
struct User {
    name: String,
    age: i32,
    address: String,
}

let mut fory_v1 = Fory::default().compatible(true);
fory_v1.register::<User>(1);

// Service B: Version 2 (evolved independently)
#[derive(ForyObject)]
struct User {
    name: String,
    age: i32,
    // address removed
    phone: Option<String>,     // New field
    metadata: HashMap<String, String>,  // Another new field
}

let mut fory_v2 = Fory::default().compatible(true);
fory_v2.register::<User>(1);

// V1 data deserializes into V2 structure
let v1_bytes = fory_v1.serialize(&user_v1);
let user_v2: User = fory_v2.deserialize(&v1_bytes)?;
// Missing fields get default values automatically

Compatibility rules:

  • ✅ Add new fields (default values applied)
  • ✅ Remove fields (skipped during deserialization)
  • ✅ Reorder fields (matched by name)
  • ✅ Change nullability (T ↔ Option<T>)
  • ❌ Type changes (except nullable variants)

This is critical for zero-downtime deployments and polyglot microservices.

The Technical Foundation​

Protocol Design​

Apache Fory uses a sophisticated binary protocol designed for both performance and flexibility:

| fory header | reference meta | type meta | value data |

Key innovations:

  1. Efficient encoding: Variable-length integers, compact type IDs, bit-packed flags
  2. Reference tracking: Deduplicates shared objects automatically (serialize once, reference thereafter)
  3. Meta compression: Gzip compression for type metadata in meta-sharing mode
  4. Little-endian layout: Optimized for modern CPU architectures

Compile-Time Code Generation​

Unlike reflection-based frameworks, Apache Fory generates serialization code at compile time via procedural macros:

use fory::ForyObject;

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

// Macro generates:
// - fory_write_data() for serialization
// - fory_read_data() for deserialization
// - fory_reserved_space() for buffer pre-allocation
// - fory_get_type_id() for type registration

Benefits:

  • ⚡ Zero runtime overhead: No reflection, no vtable lookups
  • 🛡️ Type safety: Compile-time errors instead of runtime panics
  • 📦 Small binary size: Only code for types you actually use
  • 🔍 IDE support: Full autocomplete and error checking

Architecture​

Apache Fory Rust consists of three focused crates:

fory/            # High-level API
  └─ Convenience wrappers, derive re-exports

fory-core/       # Core serialization engine
  ├─ fory.rs         # Main entry point
  ├─ buffer.rs       # Zero-copy binary I/O
  ├─ serializer/     # Type-specific serializers
  ├─ resolver/       # Type registration & dispatch
  ├─ meta/           # Meta string compression
  └─ row/            # Row format implementation

fory-derive/     # Procedural macros
  ├─ object/         # ForyObject derive macro
  └─ fory_row.rs    # ForyRow derive macro

This modular design ensures clean separation of concerns and makes the codebase maintainable.

Benchmarks: Real-World Performance​

DatatypeSizeOperationFory TPSJSON TPSProtobuf TPSFastest
companysmallserialize10,063,906761,673896,620fory
companymediumserialize412,50733,83537,590fory
companylargeserialize9,183793880fory
ecommerce_datasmallserialize2,350,729206,262256,970fory
ecommerce_datamediumserialize59,9774,6995,242fory
ecommerce_datalargeserialize3,727266295fory
personsmallserialize13,632,5221,345,1891,475,035fory
personmediumserialize3,839,656337,610369,031fory
personlargeserialize907,85379,63191,408fory
simple_listsmallserialize27,726,9454,874,9574,643,172fory
simple_listmediumserialize4,770,765401,558397,551fory
simple_listlargeserialize606,06141,06144,565fory
simple_mapsmallserialize22,862,3693,888,0252,695,999fory
simple_mapmediumserialize2,128,973204,319193,132fory
simple_maplargeserialize177,84718,41918,668fory
simple_structsmallserialize35,729,59810,167,0458,633,342fory
simple_structmediumserialize34,988,2799,737,0986,433,350fory
simple_structlargeserialize31,801,5584,545,0417,420,049fory
system_datasmallserialize5,382,131468,033569,930fory
system_datamediumserialize174,24011,89614,753fory
system_datalargeserialize10,6718761,040fory

When to Use Apache Fory Rust​

✅ Ideal Use Cases​

  1. Microservices with polyglot teams

    • Different services in different languages
    • Need seamless data exchange without schema files
    • Schema evolution across independent deployments

  2. High-performance data pipelines

    • Processing millions of records per second
    • Memory-constrained environments (use row format)
    • Analytics workloads with selective field access

  3. Complex domain models

    • Circular references (parent-child relationships, graphs)
    • Polymorphic types (trait objects, inheritance hierarchies)
    • Rich object graphs with shared references

  4. Real-time systems

    • Low-latency requirements (<1ms serialization)
    • Memory-mapped file access
    • Zero-copy deserialization critical

⚠️ Consider Alternatives If​

  1. You need human-readable data: Use JSON/YAML for debugging
  2. You need long-term storage format: Use Parquet for data lakes
  3. Your data is trivial: serde + bincode is simpler for basic types

Getting Started in 5 Minutes​

Installation​

Add to Cargo.toml:

[dependencies]
fory = "0.13"

Basic Object Serialization​

use fory::{Fory, Error, ForyObject};

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

fn main() -> Result<(), Error> {
    let mut fory = Fory::default();
    fory.register::<User>(1);  // Register with unique ID
    let user = User {
        name: "Alice".to_string(),
        age: 30,
        email: "alice@example.com".to_string(),
    };
    // Serialize
    let bytes = fory.serialize(&user);
    // Deserialize
    let decoded: User = fory.deserialize(&bytes)?;
    assert_eq!(user, decoded);
    Ok(())
}

Cross-Language Serialization​

use fory::Fory;

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

// Register with id/namespace for cross-language compatibility
fory.register_by_namespace::<User>(1);
// fory.register_by_namespace::<User>("example", "User");

let bytes = fory.serialize(&user);
// This can now be deserialized in Java, Python, Go, etc.

Register types with consistent IDs or names across all languages:

  • By ID (fory.register::<User>(1)): Faster serialization, more compact encoding, but requires coordination to avoid ID conflicts
  • By name (fory.register_by_name::<User>("example.User")): More flexible, less prone to conflicts, easier to manage across teams, but slightly larger encoding

Supported Types​

Apache Fory Rust supports a comprehensive type system:

Primitives: bool, i8, i16, i32, i64, f32, f64, String

Collections: Vec<T>, HashMap<K,V>, BTreeMap<K,V>, HashSet<T>, Option<T>

Smart Pointers: Box<T>, Rc<T>, Arc<T>, RcWeak<T>, ArcWeak<T>, RefCell<T>, Mutex<T>

Date/Time: chrono::NaiveDate, chrono::NaiveDateTime

Custom Types: Derive ForyObject for object graphs, ForyRow for row format

Trait Objects: Box<dyn T>, Rc<dyn T>, Arc<dyn T>, Rc<dyn Any>, Arc<dyn Any>

Roadmap: What's Next​

Apache Fory Rust is production-ready today, but we're just getting started and continuing active development:

✅ Shipped in v0.13​

  • ✅ Static codegen via procedural macros
  • ✅ Row format serialization with zero-copy
  • ✅ Cross-language object graph serialization
  • ✅ Shared and circular reference tracking
  • ✅ Weak pointer support (RcWeak, ArcWeak)
  • ✅ Trait object serialization (Box/Rc/Arc)
  • ✅ Schema evolution in compatible mode

🚧 Coming Soon​

  • Cross-language reference serialization: serialize Rc/Arc to/from other languages.
  • Partial row updates: Mutate row format in-place

🎯 Help Wanted​

We're actively seeking contributors for:

  • Performance tuning: Profile and optimize hot paths
  • Documentation: More examples, tutorials, and guides
  • Testing: Fuzzing, property tests, edge case coverage

Production Considerations​

Thread Safety​

Fory becomes fully thread-safe after registration is complete. Once every type is registered (which requires &mut Fory), wrap the instance in an Arc and freely share it across worker threads for concurrent serialization and deserialization.

use fory::Fory;
use std::{sync::Arc, thread};

let mut fory = Fory::default();
fory.register::<Item>(1)?;
let fory = Arc::new(fory); // `Fory` is Send + Sync once registration is done

let item = Item::default();
let handles: Vec<_> = (0..4)
    .map(|_| {
        let fory = Arc::clone(&fory);
        let input = item.clone();
        thread::spawn(move || {
            let bytes = fory.serialize(&input);
            let decoded: Item = fory.deserialize(&bytes).expect("valid data");
            (bytes, decoded)
        })
    })
    .collect();

for handle in handles {
    let (bytes, decoded) = handle.join().expect("thread finished");
    // work with `bytes` / `decoded`
}

Error Handling​

Apache Fory uses Result<T, Error> for all fallible operations:

use fory::Error;

match fory.deserialize::<User>(&bytes) {
    Ok(user) => process_user(user),
    Err(Error::TypeMismatch) => log::error!("Schema mismatch"),
    Err(Error::BufferTooShort) => log::error!("Incomplete data"),
    Err(e) => log::error!("Deserialization failed: {}", e),
}

Documentation​

Community and Contribution​

Apache Fory is an Apache Software Foundation project with a vibrant, growing community:

How to Contribute​

We welcome contributions of all kinds:

  1. Code: Implement features from the roadmap
  2. Docs: Write tutorials, examples, and guides
  3. Testing: Add benchmarks, fuzz tests, integration tests
  4. Feedback: Report bugs, request features, share use cases

See CONTRIBUTING.md for guidelines.

License​

Apache Fory is licensed under the Apache License 2.0, a permissive open-source license that allows commercial use, modification, and distribution.

Conclusion​

Apache Fory Rust represents a paradigm shift in serialization:

  • No more trade-offs: Get performance and flexibility
  • No more boilerplate: Derive macros handle the complexity
  • No more lock-in: Trait-object and shared reference support by nature

Whether you're building microservices, data pipelines, or real-time systems, Apache Fory Rust delivers the performance you need with the ergonomics you deserve.

Try it today:

cargo add fory

Join the community:

git clone https://github.com/apache/fory.git
cd fory/rust
cargo test --features tests

Share your experience:

  • Write a blog post about your use case
  • Present at your local Rust meetup
  • Contribute benchmarks from your domain
]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.13.0 Released]]> https://fory.apache.org/blog/fory_0_13_0_release 2025-10-27T00:00:00.000Z The Apache Fory team is pleased to announce the 0.13.0 release. This is a major release that includes 217 PR from 19 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

  • Dynamic Trait Object Serialization for Rust
  • Shared/Circular ownership serialization for Rust
  • Schema Forward/Backward compatibilify for Rust
  • Drop-in Replacement for Python pickle: support local function/classes/__reduce__/__getstate__ serialization
  • Schema Forward/Backward compatibilify for Python dataclass
  • Support codegen for xlang mode in java
  • Primitive array compression using SIMD
  • Compact Row Codec for Row Format
  • Schema Forward/Backward compatibilify for Go
  • Ahead-of-time codegen for golang struct serialization

Rust: First Release Highlights​

This is the first Apache Fory Rust release, delivering a complete, high‑performance serialization stack. If you build Rust services or libraries, you can now use Fory natively with strong typing, performance, and schema evolution.

  • Derive-based object graph serialization via #[derive(ForyObject)]
  • Polymorphism for trait objects: Box<dyn Trait>, Rc<dyn Trait>, Arc<dyn Trait>, plus dyn Any
  • Shared and circular reference tracking: Rc/Arc and RcWeak/ArcWeak
  • Forward/backward compatible schema evolution (Compatible mode)
  • Zero-copy Row format via #[derive(ForyRow)] with selective field access
  • Thread-safe and multi-thread capable serialization (context pool)
  • Broad collection support (e.g., VecDeque, LinkedList, BTreeMap, BTreeSet, BinaryHeap)

Quick start (minimal example):​

use fory::{Fory, Error};
use fory::ForyObject;

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

fn main() -> Result<(), Error> {
    let mut fory = Fory::default();
    fory.register::<User>(1)?;

    let user = User { name: "Alice".into(), age: 30, email: "alice@example.com".into() };
    let bytes = fory.serialize(&user)?;
    let decoded: User = fory.deserialize(&bytes)?;
    assert_eq!(user, decoded);
    Ok(())
}

Rust Benchmarks​

Below are serialize throughput results (TPS; higher is better) comparing Fory with JSON and Protobuf across multiple datasets and sizes.

DatatypeSizeOperationFory TPSJSON TPSProtobuf TPSFastest
companysmallserialize10,063,906761,673896,620fory
companymediumserialize412,50733,83537,590fory
companylargeserialize9,183793880fory
ecommerce_datasmallserialize2,350,729206,262256,970fory
ecommerce_datamediumserialize59,9774,6995,242fory
ecommerce_datalargeserialize3,727266295fory
personsmallserialize13,632,5221,345,1891,475,035fory
personmediumserialize3,839,656337,610369,031fory
personlargeserialize907,85379,63191,408fory
simple_listsmallserialize27,726,9454,874,9574,643,172fory
simple_listmediumserialize4,770,765401,558397,551fory
simple_listlargeserialize606,06141,06144,565fory
simple_mapsmallserialize22,862,3693,888,0252,695,999fory
simple_mapmediumserialize2,128,973204,319193,132fory
simple_maplargeserialize177,84718,41918,668fory
simple_structsmallserialize35,729,59810,167,0458,633,342fory
simple_structmediumserialize34,988,2799,737,0986,433,350fory
simple_structlargeserialize31,801,5584,545,0417,420,049fory
system_datasmallserialize5,382,131468,033569,930fory
system_datamediumserialize174,24011,89614,753fory
system_datalargeserialize10,6718761,040fory

Note: Results depend on hardware, dataset, and implementation versions. See the Rust guide for how to run benchmarks yourself: https://github.com/apache/fory/blob/main/benchmarks/rust_benchmark/README.md

Python: Drop‑in Replacement for pickle​

pyfory now acts as a high‑performance drop‑in replacement for pickle/cloudpickle, while keeping the same simple API and adding security and performance features.

  • Serialize any Python object in Python‑native mode (xlang=False): global/local functions, lambdas, global/local classes, instance/class/static methods
  • Honors Python hooks: __getstate__, __setstate__, __reduce__, __reduce_ex__
  • Reference tracking for shared/circular graphs with ref=True
  • Pickle protocol 5 out‑of‑band buffers for zero‑copy via pickle.PickleBuffer (NumPy, Pandas, etc.)
  • Security: strict=True for registration‑based safety and DeserializationPolicy for fine‑grained control
  • Threading: ThreadSafeFory for safe multi‑thread use
  • Familiar API: dumps/loads are aliases of serialize/deserialize

Quick start:

import pyfory

# Drop-in replacement for pickle/cloudpickle
fory = pyfory.Fory(xlang=False, ref=True, strict=False)

def make_multiplier(k):
    def mul(x):
        return k * x
    return mul

binary = fory.dumps(make_multiplier(10))
assert fory.loads(binary)(3) == 30

Read more: Python Guide – https://fory.apache.org/docs/latest/python_serialization/

Features​

Bug Fix​

Other Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.12.3...v0.13.0-rc2

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.12.3 Released]]> https://fory.apache.org/blog/fory_0_12_3_release 2025-09-23T00:00:00.000Z The Apache Fory team is pleased to announce the 0.12.3 release. This is a minor release that includes 4 PR. See the Install Page to learn how to get the libraries for your platform.

Features​

Bug Fixes​

Full Changelog: https://github.com/apache/fory/compare/v0.12.2...v0.12.3

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.12.2 Released]]> https://fory.apache.org/blog/fory_0_12_2_release 2025-09-08T00:00:00.000Z The Apache Fory team is pleased to announce the 0.12.2 release. This is a minor release that includes 10 PR from 4 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Features​

Bug Fixes​

Improvements​

Full Changelog: https://github.com/apache/fory/compare/v0.12.1...v0.12.2

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.12.1 Released]]> https://fory.apache.org/blog/fory_0_12_1_release 2025-09-01T00:00:00.000Z The Apache Fory team is pleased to announce the 0.12.1 release. This is a major release that includes 24 PR from 5 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Features​

Bug Fixes​

Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.12.0...v0.12.1

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.12.0 Released]]> https://fory.apache.org/blog/fory_0_12_0_release 2025-08-18T00:00:00.000Z The Apache Fory team is pleased to announce the 0.12.0 release. This is a major release that includes 64 PR from 9 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

  • [Python] Support Python __getstate__/__setstate__/__reduce__ serialization protocol
  • [Python] Support serialize python function
  • [Java] Use JDK11 for fory-format module
  • [Scala]Support default value for scala case/pojo classes when deseralizing
  • [Kotlin] Support default value for kotlin data classes when deserializing

Features​

Bug Fix​

Other Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.11.2...v0.12.0

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Apache Fory™ Graduates to Top-Level Apache Project]]> https://fory.apache.org/blog/apache-fory-graduated 2025-07-18T00:00:00.000Z Hello, everyone! I'm pleased to announce that Apache Fory™ has graduated from the Apache Incubator to become a Top-Level Project (TLP) of the Apache Software Foundation, signifying its technical maturity and sustainable open-source governance under the Apache Way.

What is Apache Fory?​

Apache Fory is a blazingly-fast multi-language serialization framework that revolutionizes data exchange between systems and languages. By leveraging JIT compilation and zero-copy techniques, Fory delivers up to 170x faster performance compared to other serialization frameworkds while being extremely easy to use.

Key Features:​

  • 🌐 Cross-language serialization: Java, Python, C++, Go, JavaScript, Rust, Scala, Kotlin
  • ⚡️ Zero-copy optimization: Minimizes memory overhead for large datasets
  • 🔄 Schema evolution: Forward/backward compatibility for evolving data structures
  • 🔒 Security-first: Class registration prevents deserialization vulnerabilities
  • 📦 Multiple protocols: Object graph, Row format, and Java-compatible modes

Quick Start​

Java serialization example:

Fory fory = Fory.builder().build();
fory.register(DataModel.class);

DataModel obj = new DataModel(/*...*/);
byte[] bytes = fory.serialize(obj);
DataModel restored = (DataModel) fory.deserialize(bytes);

Python serialization example

from dataclasses import dataclass
import pyfory

class Foo:
    name: str:
    age: int
pyfory.register(Foo)
bytes = pyfory.serialize(Foo("Shawn", 30))  # Ultra-fast encoding
restored = pyfory.deserialize(bytes)  # Instant decoding

The Incubation Journey​

Since entering the Apache Incubator in December 2023, Fory has achieved significant milestones.

Community Growth​

  • 👥 90+ contributors
  • 🔧 6 new committers added, with 1 promoted to PPMC
  • 🤝 Diverse adoption across fintech, e-commerce, and cloud

Technical Progress​

  • 🚀 14 ASF-compliant releases (0.5.0 to 0.11.2)
  • 🔄 4 release managers ensuring sustainable operations
  • ™ Trademark resolution: Successful rename from Fury → Fory
  • ✅ Maturity validation: Full compliance with ASF graduation requirements

Apache Way Adoption​

  • 📬 100% public discussions on dev@ mailing lists
  • 🗳️ Consensus-driven decisions through formal voting
  • 🌐 Complete infrastructure migration to Fory namespace

Why Graduation Matters​

Graduation signifies that Fory has demonstrated:

  • Sustainable governance with diverse PMC leadership
  • Enterprise-ready stability through rigorous releases
  • Community independence with no vendor dominance
  • ASF policy compliance including security and licensing

What's Next​

As a Top-Level Project, Fory's roadmap includes:

  • Enhanced Capabilities
    • Improved schema evolution for cross-language compatibility
    • Producation ready support for Rust/C++ serialization
    • Optimize Pyfory Performance continuously and provide drop-in replacement support for pickle
  • Ecosystem Integration
    • GRPC Integration
    • Protobuf Migration Tool
  • Community Growth
    • Comprehensive user documentation
    • Structured mentorship program for new contributors
    • Production case studies with early adopters

Get Involved​

Experience Fory's performance:

Java:

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

Python:

pip install pyfory

Join our community:

Acknowledgements​

The PMC Members of the Fory project are listed as follows, with big thanks to their significant contributions:

Big thanks to all contributors who submitted code, reported issues, and improved documentation. This achievement belongs to the entire Apache Fory community!

]]> Shawn Yang https://github.com/chaokunyang <![CDATA[Fory v0.11.2 Released]]> https://fory.apache.org/blog/fory_0_11_2_release 2025-07-10T00:00:00.000Z The Apache Fory team is pleased to announce the 0.11.2 release. This is a major release that includes 13 PR from 6 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Features​

Bug Fixes​

Documentation​

Chores​

Full Changelog: https://github.com/apache/fory/compare/v0.11.1...v0.11.2

]]> Pan Li https://github.com/pandalee99 <![CDATA[Fory v0.11.1 Released]]> https://fory.apache.org/blog/fory_0_11_1_release 2025-06-27T00:00:00.000Z The Apache Fory team is pleased to announce the 0.11.1 release. This is a major release that includes 32 PR from 13 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Features​

Bug Fix​

Other Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.11.0...v0.11.1-rc1

]]> Liangliang Sui https://github.com/LiangliangSui <![CDATA[Fory v0.11.0 Released]]> https://fory.apache.org/blog/fory_0_11_0_release 2025-06-17T00:00:00.000Z The Apache Fory team is pleased to announce the 0.11.0 release. This is a major release that includes 177 PR from 39 distinct contributors. See the Install Page to learn how to get the libraries for your platform.

Highlights​

  • Add Dart Serialization support
  • Chunk-based map serialization for Java/Python with performance optimizations and XLang support
  • Cross-language homogeneous collection serialization between Java/Python
  • Refactor XLang type system and serialization for fory go
  • Performance improvements in Python (dict/tuple/list serialization, C-API optimization)
  • Row format evolution with support for Optional, Records, nested beans, and interface synthesis
  • Unify Java and XLang object serialization with cross-language compatibility for enums, time, arrays, and more
  • Renamed Apache Fury to Apache Fory

Breaking Changes​

  • Renamed Apache Fury to Apache Fory, this transition impacts all project components including code repositories, maven groupId, jar names, package names, documentation, and communication channels and the source release name (and location), see Rename Announcement for more details.

Features​

Bug Fix​

Other Improvements​

New Contributors​

Full Changelog: https://github.com/apache/fory/compare/v0.10.3...v0.11.0-rc2

]]> Shawn Yang https://github.com/chaokunyang