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 f50e27a405ea6abb79637df4f0f729539e1877f5
Author: chaokunyang <[email protected]>
AuthorDate: Tue Aug 4 05:58:23 2026 +0000

    πŸ”„ synced local 'docs/start/' with remote 'docs/start/'
---
 docs/start/cpp.md    |  2 +-
 docs/start/csharp.md |  2 +-
 docs/start/index.md  | 28 ++++++++++++++--------------
 docs/start/java.md   |  4 ++--
 docs/start/kotlin.md |  8 ++++----
 docs/start/scala.md  |  8 ++++----
 6 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/docs/start/cpp.md b/docs/start/cpp.md
index bc8384134b..ac0da1011a 100644
--- a/docs/start/cpp.md
+++ b/docs/start/cpp.md
@@ -33,7 +33,7 @@ cmake --version
 
 ## Object Serialization
 
-Use xlang mode for data shared with other Fory runtimes or native mode for
+Use xlang mode for data shared with Fory implementations in other languages or 
native mode for
 C++-only data. Fetch a released source tree and link the serialization target:
 
 ```cmake title="CMakeLists.txt"
diff --git a/docs/start/csharp.md b/docs/start/csharp.md
index 0167f6b0ad..8ab6e85791 100644
--- a/docs/start/csharp.md
+++ b/docs/start/csharp.md
@@ -21,7 +21,7 @@ license: |
 
 Fory C# provides xlang Object Serialization, generated models, and Fory gRPC.
 The `Apache.Fory` NuGet package requires .NET 8 or later and includes both the
-runtime and source generator.
+serialization library and source generator.
 
 ## Verify the Toolchain
 
diff --git a/docs/start/index.md b/docs/start/index.md
index ea48248b39..cfc88ef686 100644
--- a/docs/start/index.md
+++ b/docs/start/index.md
@@ -19,8 +19,8 @@ license: |
   limitations under the License.
 ---
 
-Start with a runtime page below. Each page includes a release-pinned 
installation,
-a runnable object-serialization round trip, the modes supported by that 
runtime,
+Start with a language page below. Each page includes a release-pinned 
installation,
+a runnable object-serialization round trip, the modes available for that 
language,
 and a short path into every additional Fory capability available there.
 
 Apache Foryβ„’ releases are available as source artifacts and language-specific
@@ -29,19 +29,19 @@ packages. For source downloads, see the Apache Foryβ„’
 
 ## First Five Minutes
 
-1. Choose the runtime used by your application.
-2. Install the package shown on that runtime page.
+1. Choose the language used by your application.
+2. Install the package shown on that language page.
 3. Run its minimal serialize/deserialize example.
-4. Select xlang mode for cross-language data or native mode for same-runtime 
data
-   when both are available.
+4. Select xlang mode for cross-language data or native mode for data handled 
by one Fory
+   implementation family when both are available.
 5. Continue to the capability guide for production configuration and advanced 
APIs.
 
-## Choose a Runtime
+## Choose a Language
 
-Each runtime page provides a release-pinned installation snippet, a minimal
+Each language page provides a release-pinned installation snippet, a minimal
 round trip for an application project, and the next capability-specific steps:
 
-| Runtime               | Setup                                  |
+| Language              | Setup                                  |
 | --------------------- | -------------------------------------- |
 | Java                  | [Java](java.md)                        |
 | Python                | [Python](python.md)                    |
@@ -57,15 +57,15 @@ round trip for an application project, and the next 
capability-specific steps:
 
 ## What You Can Build
 
-| Capability           | Use it for                                            
                         | Available runtimes                                   
            | Detailed guide                                           |
+| Capability           | Use it for                                            
                         | Available languages                                  
            | Detailed guide                                           |
 | -------------------- | 
------------------------------------------------------------------------------ 
| ---------------------------------------------------------------- | 
-------------------------------------------------------- |
-| Object Serialization | Reconstruct object graphs, including shared 
references and schema changes      | All runtimes                               
                      | [Object 
Serialization](../object-serialization/index.md) |
+| Object Serialization | Reconstruct object graphs, including shared 
references and schema changes      | All languages                              
                      | [Object 
Serialization](../object-serialization/index.md) |
 | Row Format           | Trusted analytical data with zero-copy, random, or 
partial field access        | Java, Python, C++, Rust                           
               | [Row Format](../row-format/index.md)                     |
 | Fory JSON            | High-performance standard JSON mapping                
                         | Java                                                 
            | [Fory JSON](../json/index.md)                            |
-| Fory IDL             | Generate native models and serializers from Fory, 
protobuf, or FlatBuffers IDL | All runtimes                                     
                | [Fory IDL and Compiler](../compiler/index.md)            |
+| Fory IDL             | Generate native models and serializers from Fory, 
protobuf, or FlatBuffers IDL | All languages                                    
                | [Fory IDL and Compiler](../compiler/index.md)            |
 | Fory gRPC            | Use generated models over normal gRPC transports with 
Fory-encoded messages    | Java, Python, C++, Go, Rust, JavaScript, C#, Dart, 
Scala, Kotlin | [Fory gRPC](../grpc/index.md)                            |
 
 Object Serialization uses xlang mode for portable cross-language data. Java,
-Python, C++, Go, Rust, Scala, and Kotlin also offer native mode for
-same-runtime data. Use [Choose a Format](../introduction/choose-a-format.md)
+Python, C++, Go, Rust, Scala, and Kotlin also offer native mode for data 
handled by one Fory
+implementation family. Use [Choose a 
Format](../introduction/choose-a-format.md)
 when you have not yet chosen a format.
diff --git a/docs/start/java.md b/docs/start/java.md
index bc38eedafd..fbd52f4440 100644
--- a/docs/start/java.md
+++ b/docs/start/java.md
@@ -36,7 +36,7 @@ mvn -version
 ## Object Serialization
 
 Use Object Serialization for object graphs. Xlang mode produces data that other
-Fory runtimes can read; native mode supports a broader JVM object surface.
+Fory implementations in other languages can read; native mode supports a 
broader JVM object surface.
 
 Maven:
 
@@ -124,7 +124,7 @@ object mapping, annotations, Android, GraalVM, and security.
 - **Fory IDL and Compiler** generates Java models and registration helpers 
from Fory IDL, protobuf IDL, or FlatBuffers IDL. See [Compiler Getting 
Started](../compiler/getting-started.md) and the [Java generated-code 
guide](../compiler/generated-code/java.md).
 - **Fory gRPC** uses normal grpc-java transports with Fory-encoded request and 
response objects. See [Java gRPC](../grpc/java.md).
 
-## Runtime Notes
+## Platform Notes
 
 - On JDK 25 and later, follow the setup in
   [Java Object Serialization](../object-serialization/java/index.md).
diff --git a/docs/start/kotlin.md b/docs/start/kotlin.md
index e2fe8f74ab..96ceb7a4f9 100644
--- a/docs/start/kotlin.md
+++ b/docs/start/kotlin.md
@@ -32,7 +32,7 @@ java -version
 
 ## Object Serialization
 
-Add the runtime to the application module:
+Add the Fory Kotlin library to the application module:
 
 ```kotlin title="build.gradle.kts"
 dependencies {
@@ -67,8 +67,8 @@ If the project applies Gradle's `application` plugin, run its 
application task:
 ./gradlew run
 ```
 
-Use xlang mode for data shared with other Fory runtimes or native mode for
-Kotlin/JVM-only data. Continue with
+Use xlang mode when a peer uses a different Fory implementation family; use 
native mode for data
+within the JVM Fory implementation family. Continue with
 [Kotlin Object Serialization](../object-serialization/kotlin/index.md),
 
[xlang](../object-serialization/kotlin/basic-serialization.md#cross-language-interoperability),
 or
 [native mode](../object-serialization/kotlin/native.md).
@@ -77,4 +77,4 @@ Kotlin/JVM-only data. Continue with
 
 - **Fory IDL and Compiler** generates Kotlin models and registration helpers 
through KSP. See [Compiler Getting Started](../compiler/getting-started.md) and 
the [Kotlin generated-code guide](../compiler/generated-code/kotlin.md).
 - **Fory gRPC** uses grpc-kotlin and grpc-java transports with Fory-encoded 
messages. See [Kotlin gRPC](../grpc/kotlin.md).
-- **Android** uses generated serializers with the same Fory Kotlin runtime. 
See [Android Object Serialization](../object-serialization/java/android.md).
+- **Android** uses generated serializers with the same Fory Kotlin library. 
See [Android Object Serialization](../object-serialization/java/android.md).
diff --git a/docs/start/scala.md b/docs/start/scala.md
index 5e8a83c51b..060b4df090 100644
--- a/docs/start/scala.md
+++ b/docs/start/scala.md
@@ -20,7 +20,7 @@ license: |
 ---
 
 Fory Scala provides binary Object Serialization, generated models, and Fory
-gRPC. The runtime artifact supports Scala 2.13 and Scala 3; generated Scala
+gRPC. The Fory Scala artifact supports Scala 2.13 and Scala 3; generated Scala
 models require Scala 3.
 
 ## Verify the Toolchain
@@ -33,7 +33,7 @@ sbt --version
 
 ## Object Serialization
 
-Add the runtime to `build.sbt`:
+Add the Fory Scala library to `build.sbt`:
 
 ```sbt
 ThisBuild / scalaVersion := "3.3.1"
@@ -66,8 +66,8 @@ object ScalaExample {
 sbt run
 ```
 
-Use xlang mode for data shared with other Fory runtimes or native mode for
-Scala/JVM-only data. Continue with
+Use xlang mode when a peer uses a different Fory implementation family; use 
native mode for data
+within the JVM Fory implementation family. Continue with
 [Scala Object Serialization](../object-serialization/scala/index.md),
 
[xlang](../object-serialization/scala/basic-serialization.md#cross-language-interoperability),
 or
 [native mode](../object-serialization/scala/native.md).


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

Reply via email to