CHchaokunyang·Aug 12, 2026
fory json source code: https://github.com/apache/fory/blob/main/java/fory-json/READ...
In Apache Fory JSON: Fastest Java JSON Serialization, 10x Faster Than Jackson/Gsonapache
fory
Java2023–2026
apache / fory
fory
A blazingly fast multi-language serialization framework for idiomatic domain objects, schema IDL, and cross-language data exchange.
4Distinct people
32Mentions
0Explicit recommenders
4.6KGitHub stars
What to know before exploring
What it is
A blazingly fast multi-language serialization framework for idiomatic domain objects, schema IDL, and cross-language data exchange.
GitHub
Where it is used
No documented product use has been verified yet.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 12:54:37 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year32 dated mentions
Observed mentions: 2023-07-28 01:53:42 UTC to 2026-08-12 16:05:39 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 10 | 5 | 5 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 5 | 2 | 3 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 12 | 3 | 9 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 5 | 2 | 3 |
What Hacker News says
32 sourcesApache Fory Serialization 1.2.0: JDK 25 support without sun.misc.Unsafe
1 points · Open discussionIf 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
With fory first-class object graph serialziation support, you can serialize object graphs without manual *_id link reconstruction or rewriting your entire schema into Fory Schema.
1. GitHub: https://github.com/apache/fory
2. Compiler docs: https://fory.apache.org/docs/compiler
In Extend Protobuf/FlatBuffers Schema IDL with Shared/Circular Reference Support1. Docs https://fory.apache.org/docs/compiler
2. GitHub https://github.com/apache/fory
3. Benchmarks https://github.com/apache/fory/tree/main/docs/benchmarks
In Show HN: First IDL for Object-Graph Serialization (Apache Fory IDL)Show HN: Fory C++ Serialization – Polymorphism, Circular Refs, 12x vs. Protobuf
Apache Fory's C++ serialization is our latest support for c++
Highlights:
1. Automatic idiomatic cross-language serializaton, no adapter layer, serialize in C++, deserialize in Python.
2. Polymorphism via smart pointers. Fory detects std::is_polymorphic<T> automatically. Serialize through a shared_ptr<Animal>, get a Dog* back — zero boilerplate.
3. Circular/shared reference tracking. Shared objects are serialized once and encoded as back-references. Cycles don't overflow the stack.
4. Schema evolution. Compatible mode matches fields by name/id, not position. Add fields on one side without coordinating deployments.
5. IDL compiler (optional). `foryc ecommerce.fdl --cpp_out ./gen` generates idiomatic code for every language from one schema. Supports union →
std::variant, optional, ref → std::shared_ptr, weak refs, lists, maps.
6. Row format
Read the rest
. O(1) random field access by index — useful for analytics workloads where you only read a few fields per record.
Throughput vs. Protobuf: up to 12x depending on workload.
GitHub: https://github.com/apache/fory
C++ docs: https://fory.apache.org/docs/guide/cpp
I’d really like critical feedback on API ergonomics, and production fit.
You mean this file? https://github.com/apache/fory/blob/main/AGENTS.md
In Show HN: Apache Fory Rust – 10-20x faster serialization than JSON/ProtobufIf your binary has a small function set, probably not. But in a use case if you want to proxy/intercept cloud APIs, then something like Google APIs has 34K message types:
git clone https://github.com/googleapis/googleapis.git
cd googleapis
find . -name '*.proto' -and -not -name '*test*' -and -not -name '*example*' -exec grep '^message' {} \; | wc -l
I think this more speaks to the tradeoff of not having an IDL where the deserializer either knows what type to expect if it was built with the IDL file version that defined it, e.g., this recent issue:
https://github.com/apache/fory/issues/2818
But now I do see that the 4096 is just arbitrary:
If schema consistent mode is enabled globally when creating fory, type meta will be written as a fory unsigned varint of type_id. Schema evolution related meta will be ignored.
In Show HN: Apache Fory Rust – 10-20x faster serialization than JSON/ProtobufIn our Java benchmarks, Fory is actually faster than FlatBuffers — you can try it yourself here:
https://github.com/apache/fory/blob/main/java/benchmark/src/...
We haven’t tested FlatBuffers vs. Fory for Rust yet, but we plan to.
It’s also worth noting the focus is a bit different: FlatBuffers is great for certain constrained scenarios (e.g., games, embedded), while Fory is a more general‑purpose serialization framework with features like cross‑language object graph support, circular reference handling, and schema evolution.
In Show HN: Apache Fory Rust – 10-20x faster serialization than JSON/ProtobufThe https://github.com/apache/fory/blob/main/AGENTS.md is a very detailed document only for AI coding, but an excelent reference for development. But you are right, it may introduce concerns, let me remove it from landing pages
In Show HN: Apache Fory Rust – 10-20x faster serialization than JSON/ProtobufApache Fory is also a drop-in replacement for pickle/cloudpickle, you can use it to serialize code object such as local function/Classes too.
https://github.com/apache/fory/tree/main/python#serialize-lo...
When serializing code objects, pyfory is 3× higher compression ratio compared cloudpickle
And pyfory also provide extra security audit capability to avoid maliciously deserialization data attack.
In Show HN: Apache Fory Rust – 10-20x faster serialization than JSON/ProtobufIMO, not a fair benchmark.
I can see the source of an 10x improvement on an Intel(R) Xeon(R) Gold 6136 CPU @ 3.00GHz, but it drops to 3x improvement when I remove the to/from that clones or collects Vecs, and always allocate an 8K Vec instead of a ::Default for the writable buffer.
If anything, the benches should be updated in a tower service / codec generics style where other formats like protobuf do not use any Fory-related code at all.
Note also that Fory has some writer pool that is utilized during the tests:
https://github.com/apache/fory/blob/fd1d53bd0fbbc5e0ce6d53ef...
Original bench selection for Fory:
Benchmarking ecommerce_data/fory_serialize/medium: Collecting 100 samples in estimated 5.0494 s (197k it
ecommerce_data/fory_serialize/medium
time: [25.373 µs 25.605 µs 25.916 µs]
Read the rest
change: [-2.0973% -0.9263% +0.2852%] (p = 0.15 > 0.05)
No change in performance detected.
Found 4 outliers among 100 measurements (4.00%)
2 (2.00%) high mild
2 (2.00%) high severe
Compared to original bench for Protobuf/Prost:
Benchmarking ecommerce_data/protobuf_serialize/medium: Collecting 100 samples in estimated 5.0419 s (20k
ecommerce_data/protobuf_serialize/medium
time: [248.85 µs 251.04 µs 253.86 µs]
Found 18 outliers among 100 measurements (18.00%)
8 (8.00%) high mild
10 (10.00%) high severe
However after allocating 8K instead of ::Default and removing to/from it for an updated protobuf bench:
fair_ecommerce_data/protobuf_serialize/medium
time: [73.114 µs 73.885 µs 74.911 µs]
change: [-1.8410% -0.6702% +0.5190%] (p = 0.30 > 0.05)
No change in performance detected.
Found 14 outliers among 100 measurements (14.00%)
2 (2.00%) high mild
12 (12.00%) high severe
Is 4096 types enough for everyone?
https://github.com/apache/fory/blob/fd1d53bd0fbbc5e0ce6d53ef...
In Show HN: Apache Fory Rust – 10-20x faster serialization than JSON/ProtobufAre the benchmarks actually fair? See:
https://github.com/apache/fory/blob/fd1d53bd0fbbc5e0ce6d53ef...
It seems if the serialization object is not a "Fory" struct, then it is forced to go through to/from conversion as part of the measured serialization work:
https://github.com/apache/fory/blob/fd1d53bd0fbbc5e0ce6d53ef...
The to/from type of work includes cloning Strings:
https://github.com/apache/fory/blob/fd1d53bd0fbbc5e0ce6d53ef...
reallocating growing arrays with collect:
https://github.com/apache/fory/blob/fd1d53bd0fbbc5e0ce6d53ef...
I'd think that the to/from Fory types is shouldn't be part of the tests.
Also, when used in an actual system tonic would be providing a 8KB buffer to write into, not just a Vec::default() that may need to be resized multiple times:
https://github.com/hyperium/tonic/blob/147c94cd661c0015af2e5...
In Show HN: Apache Fory Rust – 10-20x faster serialization than JSON/ProtobufApache Fory Serialization Framework 0.11.2 Released
2 points · Open discussionApache Fory Serialization Framework 0.11.0 Released
2 points · Open discussionShowing the 15 most recent of 32 sources. Enable JavaScript to search and browse every indexed mention.