This is an automated email from the ASF dual-hosted git repository.

chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/fory-site.git

commit 2593560cded8394baef7e424c9de294db1ea18bc
Author: chaokunyang <[email protected]>
AuthorDate: Tue Aug 4 05:58:23 2026 +0000

    🔄 synced local 'docs/introduction/' with remote 'docs/introduction/'
---
 docs/introduction/choose-a-format.md | 14 +++++++-------
 docs/introduction/index.md           | 14 +++++++-------
 docs/introduction/support-matrix.md  |  6 +++---
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/docs/introduction/choose-a-format.md 
b/docs/introduction/choose-a-format.md
index 240590d1c5..f2fb2683c6 100644
--- a/docs/introduction/choose-a-format.md
+++ b/docs/introduction/choose-a-format.md
@@ -21,8 +21,8 @@ license: |
 
 | Format or mode | Data model                           | Use it when          
                                         | Interoperability                     
                                       | Start here                             
                  |
 | -------------- | ------------------------------------ | 
------------------------------------------------------------- | 
--------------------------------------------------------------------------- | 
-------------------------------------------------------- |
-| Xlang binary   | Portable object graphs               | Data crosses 
language boundaries                              | Shared wire format across 
supported runtimes                                | [Cross-language 
guide](../object-serialization/xlang.md) |
-| Native binary  | Runtime-native object graphs         | Producer and 
consumer use the same language                   | Same runtime family only     
                                               | [Object 
Serialization](../object-serialization/index.md) |
+| Xlang binary   | Portable object graphs               | Data crosses 
language boundaries                              | Shared wire format across 
supported Fory implementations                    | [Cross-language 
guide](../object-serialization/xlang.md) |
+| Native binary  | Language-native object graphs        | Producer and 
consumer use one Fory implementation family      | One Fory implementation 
family only                                         | [Object 
Serialization](../object-serialization/index.md) |
 | Row Format     | Random-access binary rows            | You need random 
field access or analytics-style partial reads | Standard Row is shared by Java, 
Python, C++, and Rust; Compact is Java-only | [Row Format 
guide](../row-format/index.md)               |
 | Fory JSON      | Standard JSON mapped to Java objects | Java applications 
need high-performance standard JSON         | Standard JSON text                
                                          | [Fory JSON guide](../json/index.md) 
                     |
 
@@ -30,12 +30,12 @@ Xlang and native are sibling modes of Object Serialization. 
Use them when the re
 reconstruct an object graph. Row Format and Fory JSON are separate formats, 
not additional Object
 Serialization modes.
 
-For Java, Scala, Kotlin, Python, C++, Go, and Rust, use native mode for
-same-language traffic. It avoids xlang's cross-language type mapping and
+For Java, Scala, Kotlin, Python, C++, Go, and Rust, use native mode for traffic
+within one Fory implementation family. It avoids xlang's cross-language type 
mapping and
 metadata constraints, stays closer to each language's native type system, and
 supports broader language-specific object graphs. Use it when both producer and
-consumer are in the same language family and you want the native object model
-rather than a portable cross-language schema.
+consumer use the same native wire format and you want the native object model 
rather than a
+portable cross-language schema.
 
 For Java/JVM-only systems, native mode is the replacement path for JDK
 serialization, Kryo, FST, Hessian, and Java-only Protocol Buffers payloads. For
@@ -66,7 +66,7 @@ contract; it generates models that use the relevant Fory 
capability.
 
 ## Related capabilities
 
-[Fory IDL and the compiler](../compiler/index.md) generate native models for 
supported runtimes.
+[Fory IDL and the compiler](../compiler/index.md) generate native models for 
supported languages.
 Service definitions can also generate [Fory gRPC](../grpc/index.md) code. 
Neither capability defines
 another serialization format.
 
diff --git a/docs/introduction/index.md b/docs/introduction/index.md
index 2245ef3700..74d4b16741 100644
--- a/docs/introduction/index.md
+++ b/docs/introduction/index.md
@@ -23,9 +23,9 @@ license: |
 idiomatic domain objects, schema IDL, and cross-language data exchange.
 
 Fory is built for compact, high-throughput serialization across languages and
-runtimes. It works directly with application objects, supports shared schemas
+execution platforms. It works directly with application objects, supports 
shared schemas
 when you need a stable contract, and preserves object graph features such as
-shared references, circular references, and polymorphic runtime types.
+shared references, circular references, and concrete types for polymorphic 
values.
 
 ## Quick Example
 
@@ -82,7 +82,7 @@ exchanges compact binary payloads across supported languages:
 
 - **Compact metadata**: Type metadata and field information are packed to keep 
payloads small.
 - **Schema evolution**: Compatible mode supports forward and backward 
evolution for application schemas.
-- **Object graph semantics**: Shared references, circular references, and 
polymorphic runtime types are preserved across runtimes.
+- **Object graph semantics**: Shared references, circular references, and 
concrete types for polymorphic values are preserved across languages.
 - **Type mapping**: Language-specific values are mapped through the shared 
[type mapping](../specification/xlang_type_mapping.md).
 
 ### Domain Objects First
@@ -103,7 +103,7 @@ once and generate native domain objects for each target 
language:
 - Model numbers, strings, lists, maps, arrays, enums, structs, and unions.
 - Express shared and circular references directly in the schema.
 - Generate idiomatic host-language code without introducing transport-specific 
wrapper types into user code.
-- Use schema IDL when services need a stable contract across independently 
maintained runtimes.
+- Use schema IDL when services need a stable contract across independently 
maintained Fory implementations.
 
 ### Row-Format Random Access
 
@@ -115,11 +115,11 @@ optimized for analytics and partial-read workloads:
 - **Apache Arrow integration**: Convert to columnar data for analytics 
pipelines.
 - **Multi-language support**: Exchange Standard Row Format data across Java, 
Python, C++, and Rust.
 
-### Optimized Runtimes
+### Optimized Fory Implementations
 
-Fory keeps hot paths fast without making every runtime use the same 
implementation strategy:
+Fory keeps hot paths fast without making every Fory implementation use the 
same strategy:
 
 - **Java JIT serializers**: Runtime code generation eliminates reflection 
overhead and inlines hot paths.
-- **Generated and static serializers**: Other runtimes use generated or static 
serializers where appropriate.
+- **Generated and static serializers**: Other Fory implementations use 
generated or static serializers where appropriate.
 - **Zero-copy paths**: Row format and out-of-band buffers avoid unnecessary 
copies for large values.
 - **Metadata sharing**: Repeated type information is shared or packed to 
reduce serialization overhead.
diff --git a/docs/introduction/support-matrix.md 
b/docs/introduction/support-matrix.md
index 7fee55a395..953619cd93 100644
--- a/docs/introduction/support-matrix.md
+++ b/docs/introduction/support-matrix.md
@@ -19,13 +19,13 @@ license: |
   limitations under the License.
 ---
 
-Use this matrix to confirm the documented API surface before choosing a 
capability. A runtime page
+Use this matrix to confirm the documented API surface before choosing a 
capability. A language page
 does not imply support for every Fory capability.
 
-| Capability                  | Documented runtimes                            
                                    | Interoperability                          
               |
+| Capability                  | Documented languages                           
                                    | Interoperability                          
               |
 | --------------------------- | 
----------------------------------------------------------------------------------
 | -------------------------------------------------------- |
 | Xlang object serialization  | Java, Python, C++, Go, Rust, 
JavaScript/TypeScript, C#, Swift, Dart, Scala, Kotlin | One shared xlang wire 
format                             |
-| Native object serialization | Java, Python, C++, Go, Rust, Scala, Kotlin     
                                    | Same runtime family only                  
               |
+| Native object serialization | Java, Python, C++, Go, Rust, Scala, Kotlin     
                                    | One Fory implementation family only       
               |
 | Standard Row Format         | Java, Python, C++, Rust                        
                                    | Shared Standard Row layout                
               |
 | Compact Row Format          | Java                                           
                                    | Java-only compact layout                  
               |
 | Fory JSON                   | Java                                           
                                    | Standard JSON text                        
               |


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to