diff --git a/.asf.yaml b/.asf.yaml
index 8e7acb2608..2235942cb6 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -43,9 +43,9 @@ github:
     - cross-language
     - multiple-language
   enabled_merge_buttons:
-    squash:  true
-    merge:   false
-    rebase:  false
+    squash: true
+    merge: false
+    rebase: false
   protected_branches:
     main:
       required_status_checks:
@@ -63,8 +63,8 @@ github:
     releases-0.1.2: {}
 
 notifications:
-  commits:      commits@fury.apache.org
-  issues:       commits@fury.apache.org
+  commits: commits@fury.apache.org
+  issues: commits@fury.apache.org
   pullrequests: commits@fury.apache.org
-  jobs:         commits@fury.apache.org
-  discussions:  commits@fury.apache.org
+  jobs: commits@fury.apache.org
+  discussions: commits@fury.apache.org
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index 2ce165de78..48057df2d9 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -17,7 +17,7 @@
 
 name: Bug report
 description: File a bug report
-labels: [ "bug" ]
+labels: ["bug"]
 body:
   - type: markdown
     attributes:
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
index 1a75571713..aa049212a1 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -18,7 +18,7 @@
 name: 🚀 Feature Request
 description: I have a suggestion (and may want to implement it 🙂)!
 title: "[<Fury component: Protocol|Java|Python|C++|JavaScript|etc...>] "
-assignees: ''
+assignees: ""
 labels: ["new feature"]
 
 body:
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index fcd36c1e88..1dd5eb493e 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -14,7 +14,6 @@ Contribution Checklist
 
 <!-- Describe the purpose of this PR. -->
 
-
 ## Related issues
 
 <!--
@@ -25,7 +24,6 @@ Is there any related issue? Please attach here.
 - #xxxx2
 -->
 
-
 ## Does this PR introduce any user-facing change?
 
 <!--
@@ -35,7 +33,6 @@ If any user-facing interface changes, please [open an issue](https://github.com/
 - [ ] Does this PR introduce any public API change?
 - [ ] Does this PR introduce any binary protocol compatibility change?
 
-
 ## Benchmark
 
 <!--
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d5e919a070..cec90a08d6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,22 +21,22 @@ on:
   push:
     branches:
       - main
-      - 'releases/**'
-      - 'deploy/**'
-      - 'test*'
+      - "releases/**"
+      - "deploy/**"
+      - "test*"
     tags:
       - v*
   pull_request:
     paths-ignore:
-      - '**/*.md'
-      - 'docs/**'
-      - 'LICENSE'
-      - '.vscode/**'
-      - '.gitignore'
-      - 'licenses/**'
-      - 'DISCLAIMER'
-      - 'NOTICE'
-    types: ['opened', 'reopened', 'synchronize']
+      - "**/*.md"
+      - "docs/**"
+      - "LICENSE"
+      - ".vscode/**"
+      - ".gitignore"
+      - "licenses/**"
+      - "DISCLAIMER"
+      - "NOTICE"
+    types: ["opened", "reopened", "synchronize"]
 
 jobs:
   java:
@@ -53,7 +53,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: ${{ matrix.java-version }}
-          distribution: 'temurin'
+          distribution: "temurin"
       - name: Install bazel
         run: ./ci/run_ci.sh install_bazel
       - name: Install python
@@ -77,7 +77,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: ${{ matrix.java-version }}
-          distribution: 'adopt-openj9'
+          distribution: "adopt-openj9"
       - name: Install bazel
         run: ./ci/run_ci.sh install_bazel
       - name: Install python
@@ -93,10 +93,10 @@ jobs:
       - uses: actions/checkout@v4
       - uses: graalvm/setup-graalvm@v1
         with:
-          java-version: '21'
-          distribution: 'graalvm'
+          java-version: "21"
+          distribution: "graalvm"
           github-token: ${{ secrets.GITHUB_TOKEN }}
-          native-image-job-reports: 'true'
+          native-image-job-reports: "true"
       - name: Build native image and run
         run: ./ci/run_ci.sh graalvm_test
 
@@ -109,7 +109,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: 8
-          distribution: 'temurin'
+          distribution: "temurin"
       - name: Install fury java
         run: cd java && mvn -T10 --no-transfer-progress clean install -DskipTests && cd -
       - name: Test
@@ -127,7 +127,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: 8
-          distribution: 'temurin'
+          distribution: "temurin"
       - name: Run CI
         run: ./ci/run_ci.sh integration_tests
 
@@ -212,7 +212,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-version: [ '1.13', '1.18' ]
+        go-version: ["1.13", "1.18"]
     steps:
       - uses: actions/checkout@v4
       - name: Setup Go ${{ matrix.go-version }}
@@ -239,7 +239,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: 21
-          distribution: 'oracle'
+          distribution: "oracle"
       - name: Check License Header
         uses: korandoru/hawkeye@v3
       - name: Set up Python 3.8
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
new file mode 100644
index 0000000000..d867657ce7
--- /dev/null
+++ b/.github/workflows/lint.yml
@@ -0,0 +1,60 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+name: ❄️ Lint
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+    paths:
+      - "**.md"
+      - "**.yml"
+      - "**.yaml"
+
+jobs:
+  markdownlint:
+    name: 🍇 Markdown
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3.1.0
+      - name: 🚀 Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18.x"
+      - run: npm install -g markdownlint-cli@0.25.0
+      - run: markdownlint '**/*.md'
+
+  yamllint:
+    name: 🍏 YAML
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3.1.0
+      - uses: actions/setup-python@v4.1.0
+        with:
+          python-version: "3.x"
+          architecture: "x64"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install yamllint
+      - name: 🧹 YAML Lint
+        run: |
+          yamllint .
diff --git a/.github/workflows/release-java-snapshot.yaml b/.github/workflows/release-java-snapshot.yaml
index a267e484cb..c57b644f44 100644
--- a/.github/workflows/release-java-snapshot.yaml
+++ b/.github/workflows/release-java-snapshot.yaml
@@ -32,8 +32,8 @@ jobs:
       - name: Set up Maven Central Repository
         uses: actions/setup-java@v4
         with:
-          java-version: '8'
-          distribution: 'adopt'
+          java-version: "8"
+          distribution: "adopt"
           architecture: x64
           cache: maven
           server-id: apache.snapshots.https
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 209c17c6b5..d5beee49c0 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -20,7 +20,7 @@ name: Publish Fury
 on:
   push:
     tags:
-      - 'v*'
+      - "v*"
 
 jobs:
   release-python:
diff --git a/.markdownlint.yml b/.markdownlint.yml
new file mode 100644
index 0000000000..24abaa6e2d
--- /dev/null
+++ b/.markdownlint.yml
@@ -0,0 +1,46 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# MD013 Line length
+MD013: false
+
+# MD014 Dollar signs used before commands without showing output
+MD014: false
+
+# MD024 Multiple headings with the same content
+MD024: false
+
+# MD026/no-trailing-punctuation Trailing punctuation in heading
+MD026: false
+
+# MD029/ol-prefix Ordered list item prefix
+MD029: false
+
+# MD033/no-inline-html
+MD033: false
+
+# MD034/no-bare-urls
+MD034: false
+
+# MD040/fenced-code-language
+MD040: false
+
+# MD041/first-line-heading/first-line-h1 First line in file should be a top level heading
+MD041: false
+
+# MD036/emphasis used instead of a header
+MD036: false
diff --git a/.yamllint b/.yamllint
new file mode 100644
index 0000000000..e55cddc719
--- /dev/null
+++ b/.yamllint
@@ -0,0 +1,6 @@
+extends: default
+
+rules:
+  document-start: false
+  line-length: false
+  truthy: false
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 152747ea54..31c0277d0c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -14,6 +14,7 @@ Generally we follows the [Conventional Commits](https://www.conventionalcommits.
 since we will squash and merge the PR and use the PR title as the first line of commit message.
 
 For example, here are good PR titles:
+
 - feat(java): support xxx feature
 - fix(c++): blablabla
 - chore(python): remove useless yyy file
@@ -146,8 +147,8 @@ cd python
 python setup.py develop
 ```
 
-* Use `cython --cplus -a  pyfury/_serialization.pyx` to produce an annotated HTML file of the source code. Then you can analyze interaction between Python objects and Python's C API.
-* Read more: https://cython.readthedocs.io/en/latest/src/userguide/debugging.html
+- Use `cython --cplus -a  pyfury/_serialization.pyx` to produce an annotated HTML file of the source code. Then you can analyze interaction between Python objects and Python's C API.
+- Read more: https://cython.readthedocs.io/en/latest/src/userguide/debugging.html
 
 ```bash
 FURY_DEBUG=true python setup.py build_ext --inplace
diff --git a/README.md b/README.md
index 6c65cd50b0..95d2bb0459 100644
--- a/README.md
+++ b/README.md
@@ -7,10 +7,9 @@
 [![X](https://img.shields.io/badge/@ApacheFury-follow-blue?logo=x&style=for-the-badge)](https://x.com/ApacheFury)
 [![Maven Version](https://img.shields.io/maven-central/v/org.apache.fury/fury-core?style=for-the-badge)](https://search.maven.org/#search|gav|1|g:"org.apache.fury"%20AND%20a:"fury-core")
 
-
 **Apache Fury (incubating)** is a blazingly-fast multi-language serialization framework powered by **JIT** (just-in-time compilation) and **zero-copy**, providing up to 170x performance and ultimate ease of use.
 
-https://fury.apache.org
+<https://fury.apache.org>
 
 > [!IMPORTANT]
 > Apache Fury (incubating) is an effort undergoing incubation at the Apache
@@ -19,14 +18,15 @@ https://fury.apache.org
 > Please read the [DISCLAIMER](DISCLAIMER) and a full explanation of ["incubating"](https://incubator.apache.org/policy/incubation.html).
 
 ## Features
+
 - **Multiple languages**: Java/Python/C++/Golang/JavaScript/Rust/Scala/TypeScript.
 - **Zero-copy**: Cross-language out-of-band serialization inspired
   by [pickle5](https://peps.python.org/pep-0574/) and off-heap read/write.
 - **High performance**: A highly-extensible JIT framework to generate serializer code at runtime in an async multi-thread way to speed serialization, providing 20-170x speed up by:
-    - reduce memory access by inlining variables in generated code.
-    - reduce virtual method invocation by inline call in generated code.
-    - reduce conditional branching.
-    - reduce hash lookup.
+  - reduce memory access by inlining variables in generated code.
+  - reduce virtual method invocation by inline call in generated code.
+  - reduce conditional branching.
+  - reduce hash lookup.
 - **Multiple binary protocols**: Object graph, row format, and so on.
 
 In addition to cross-language serialization, Fury also features at:
@@ -41,7 +41,9 @@ In addition to cross-language serialization, Fury also features at:
 - Supports automatic object serialization for golang.
 
 ## Protocols
+
 Fury designed and implemented multiple binary protocols for different scenarios:
+
 - **[xlang serialization format](docs/specification/xlang_serialization_spec.md)**:
   - Cross-language serialize any object automatically, no need for IDL definition, schema compilation and object to/from
     protocol conversion.
@@ -54,6 +56,7 @@ Fury designed and implemented multiple binary protocols for different scenarios:
 New protocols can be easily added based on Fury existing buffer, encoding, meta, codegen and other capabilities. All of those share the same codebase, and the optimization for one protocol can be reused by another protocol.
 
 ## Benchmarks
+
 Different serialization frameworks are suitable for different scenarios, and benchmark results here are for reference only.
 
 If you need to benchmark for your specific scenario, make sure all serialization frameworks are appropriately configured for that scenario.
@@ -62,6 +65,7 @@ Dynamic serialization frameworks support polymorphism and references, but they o
 To ensure accurate benchmark statistics, it is advisable to **warm up** the system before collecting data due to Fury's runtime code generation.
 
 ### Java Serialization
+
 In these charts below, titles containing "compatible" represent schema compatible mode: type forward/backward compatibility is enabled; while titles without "compatible" represent schema consistent mode: class schema must be the same between serialization and deserialization.
 
 Where `Struct` is a class with [100 primitive fields](https://github.com/apache/fury/tree/main/docs/benchmarks#Struct), `MediaContent` is a class from [jvm-serializers](https://github.com/eishay/jvm-serializers/blob/master/tpc/src/data/media/MediaContent.java), and `Sample` is a class from [kryo benchmark](https://github.com/EsotericSoftware/kryo/blob/master/benchmarks/src/main/java/com/esotericsoftware/kryo/benchmarks/data/Sample.java).
@@ -83,7 +87,9 @@ Where `Struct` is a class with [100 primitive fields](https://github.com/apache/
 See [benchmarks](https://github.com/apache/fury/tree/main/docs/benchmarks) for more benchmarks about type forward/backward compatibility, off-heap support, zero-copy serialization.
 
 ## Installation
+
 ### Java
+
 Nightly snapshot:
 
 ```xml
@@ -113,6 +119,7 @@ Nightly snapshot:
 ```
 
 Release version:
+
 ```xml
 <dependency>
   <groupId>org.apache.fury</groupId>
@@ -128,31 +135,38 @@ Release version:
 ```
 
 ### Scala
+
 ```sbt
 libraryDependencies += "org.apache.fury" % "fury-core" % "0.7.0"
 ```
 
 ### Python
+
 ```bash
 pip install pyfury
 ```
 
 ### JavaScript
+
 ```bash
 npm install @furyjs/fury
 ```
 
 ### Golang
+
 ```bash
 go get github.com/apache/fury/go/fury
 ```
 
 ## Quickstart
+
 Here we give a quick start about how to use Fury, see [user guide](docs/README.md) for more details about [java](docs/guide/java_serialization_guide.md), [cross language](docs/guide/xlang_serialization_guide.md), and [row format](docs/guide/row_format_guide.md).
 
 ### Fury java object graph serialization
+
 If you don't have cross-language requirements, using this mode will
 result in better performance.
+
 ```java
 import org.apache.fury.*;
 import org.apache.fury.config.*;
@@ -198,7 +212,9 @@ public class Example {
 ```
 
 ### Cross-language object graph serialization
+
 **Java**
+
 ```java
 import org.apache.fury.*;
 import org.apache.fury.config.*;
@@ -261,32 +277,34 @@ import furygo "github.com/apache/fury/go/fury"
 import "fmt"
 
 func main() {
-	type SomeClass struct {
-		F1 *SomeClass
-		F2 map[string]string
-		F3 map[string]string
-	}
-	fury := furygo.NewFury(true)
-	if err := fury.RegisterTagType("example.SomeClass", SomeClass{}); err != nil {
-		panic(err)
-	}
-	value := &SomeClass{F2: map[string]string{"k1": "v1", "k2": "v2"}}
-	value.F3 = value.F2
-	value.F1 = value
-	bytes, err := fury.Marshal(value)
-	if err != nil {
-	}
-	var newValue interface{}
-	// bytes can be data serialized by other languages.
-	if err := fury.Unmarshal(bytes, &newValue); err != nil {
-		panic(err)
-	}
-	fmt.Println(newValue)
+ type SomeClass struct {
+  F1 *SomeClass
+  F2 map[string]string
+  F3 map[string]string
+ }
+ fury := furygo.NewFury(true)
+ if err := fury.RegisterTagType("example.SomeClass", SomeClass{}); err != nil {
+  panic(err)
+ }
+ value := &SomeClass{F2: map[string]string{"k1": "v1", "k2": "v2"}}
+ value.F3 = value.F2
+ value.F1 = value
+ bytes, err := fury.Marshal(value)
+ if err != nil {
+ }
+ var newValue interface{}
+ // bytes can be data serialized by other languages.
+ if err := fury.Unmarshal(bytes, &newValue); err != nil {
+  panic(err)
+ }
+ fmt.Println(newValue)
 }
 ```
 
 ### Row format
+
 #### Java
+
 ```java
 public class Bar {
   String f1;
@@ -331,7 +349,9 @@ RowEncoder<Bar> barEncoder = Encoders.bean(Bar.class);
 Bar newBar = barEncoder.fromRow(barStruct);
 Bar newBar2 = barEncoder.fromRow(binaryArray4.getStruct(20));
 ```
+
 #### Python
+
 ```python
 @dataclass
 class Bar:
@@ -356,11 +376,13 @@ print(foo_row.f2[100000], foo_row.f4[100000].f1, foo_row.f4[200000].f2[5])
 ## Compatibility
 
 ### Schema Compatibility
+
 Fury java object graph serialization supports class schema forward/backward compatibility. The serialization peer and deserialization peer can add/delete fields independently.
 
 We plan to add the schema compatibility support of cross-language serialization after [meta compression](https://github.com/apache/fury/issues/203) is finished.
 
 ### Binary Compatibility
+
 We are still improving our protocols, thus binary compatibility is not guaranteed between Fury major releases for now.
 However, it is guaranteed between minor versions. Please
 `versioning` your data by Fury major version if you will upgrade Fury in the future, see [how to upgrade fury](https://github.com/apache/fury/blob/main/docs/guide/java_object_graph_guide.md#upgrade-fury) for further details.
@@ -368,6 +390,7 @@ However, it is guaranteed between minor versions. Please
 Binary compatibility will be guaranteed when Fury 1.0 is released.
 
 ## Security
+
 Static serialization is relatively secure. But dynamic serialization such as Fury java/python native serialization supports deserializing unregistered types, which provides more dynamics and flexibility, but also introduce security risks.
 
 For example, the deserialization may invoke `init` constructor or `equals`/`hashCode` method, if the method body contains malicious code, the system will be at risk.
diff --git a/docs/README.md b/docs/README.md
index 6de510a084..e44ca96c11 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,15 +1,18 @@
 # User Guide
+
 - For Cross Language Object Graph Guide, see [xlang serialization guide](guide/xlang_serialization_guide.md) doc.
 - For Java Object Graph Guide, see [java serialization guide](guide/java_serialization_guide.md) doc.
 - For Row Format Guide, see [row format guide](guide/row_format_guide.md) doc.
 - For Scala Guide, see [scala guide](guide/scala_guide.md) doc.
 - For using Fury with GraalVM native image, see [graalvm native image guide](guide/graalvm_guide.md) doc.
 
-# Serialization Format
+## Serialization Format
+
 - For Cross Language Serialization Format, see [xlang serialization spec](specification/xlang_serialization_spec.md) doc.
 - For Java Object Graph Format, see [java serialization spec](specification/java_serialization_spec.md) doc.
 - For Row Format, see [row format spec](specification/row_format_spec.md) doc.
 
-# Development
+## Development
+
 - For cpp debug, see [cpp debug](cpp_debug.md) doc.
 - For development, see [CONTRIBUTING](../CONTRIBUTING.md) doc.
diff --git a/docs/benchmarks/README.md b/docs/benchmarks/README.md
index 1bc562ab97..ffd6318dd3 100644
--- a/docs/benchmarks/README.md
+++ b/docs/benchmarks/README.md
@@ -1,5 +1,7 @@
 # Java Benchmarks
+
 ## System Environment
+
 - Operation System：4.9.151-015.x86_64
 - CPU：Intel(R) Xeon(R) Platinum 8163 CPU @ 2.50GHz
 - Byte Order：Little Endian
@@ -9,14 +11,19 @@
 - L3 cache： 33792K
 
 ## JMH params
+
 Don't skip **warm up**, otherwise the results aren't accurate.
+
 ```bash
  -f 1 -wi 3 -i 3 -t 1 -w 2s -r 2s -rf cs
 ```
 
-## Benchmark Data:
+## Benchmark Data
+
 ### Struct
+
 Struct is a class with 100 primitive fields:
+
 ```java
 public class Struct {
   public int f1;
@@ -27,8 +34,11 @@ public class Struct {
   public double f99;
 }
 ```
+
 ### Struct2
+
 Struct2 is a class with 100 boxed fields:
+
 ```java
 public class Struct {
   public Integer f1;
@@ -39,16 +49,23 @@ public class Struct {
   public Double f99;
 }
 ```
+
 ### MediaContent
+
 MEDIA_CONTENT is a class from [jvm-serializers](https://github.com/eishay/jvm-serializers/blob/master/tpc/src/data/media/MediaContent.java).
+
 ### Sample
+
 SAMPLE is a class from [kryo benchmark](https://github.com/EsotericSoftware/kryo/blob/master/benchmarks/src/main/java/com/esotericsoftware/kryo/benchmarks/data/Sample.java)
 
 ## Benchmark Plots
+
 ### Serialize to heap buffer
+
 Serialize data java byte array.
 
 #### Java schema consistent serialization
+
 The deserialization peer must have same class definition with the serialization peer.
 No class forward/backward compatibility are supported in this mode.
 
@@ -60,6 +77,7 @@ No class forward/backward compatibility are supported in this mode.
 </p>
 
 #### Java schema compatible serialization
+
 The deserialization peer can have different class definition with the serialization peer.
 Class forward/backward compatibility are supported in this mode.
 
@@ -71,6 +89,7 @@ Class forward/backward compatibility are supported in this mode.
 </p>
 
 #### Java schema consistent deserialization
+
 The deserialization peer must have same class definition with the serialization peer.
 No class forward/backward compatibility are supported in this mode.
 
@@ -82,6 +101,7 @@ No class forward/backward compatibility are supported in this mode.
 </p>
 
 #### Java schema compatible deserialization
+
 The deserialization peer can have different class definition with the serialization peer.
 Class forward/backward compatibility are supported in this mode.
 <p align="center">
@@ -92,9 +112,11 @@ Class forward/backward compatibility are supported in this mode.
 </p>
 
 ### Off-heap serialization
+
 Serialize data off-heap memory.
 
 #### Java schema consistent serialization
+
 The deserialization peer must have same class definition with the serialization peer.
 No class forward/backward compatibility are supported in this mode.
 <p align="center">
@@ -105,6 +127,7 @@ No class forward/backward compatibility are supported in this mode.
 </p>
 
 #### Java schema compatible serialization
+
 The deserialization peer can have different class definition with the serialization peer.
 Class forward/backward compatibility are supported in this mode.
 <p align="center">
@@ -115,6 +138,7 @@ Class forward/backward compatibility are supported in this mode.
 </p>
 
 #### Java schema consistent deserialization
+
 The deserialization peer must have same class definition with the serialization peer.
 No class forward/backward compatibility are supported in this mode.
 <p align="center">
@@ -125,6 +149,7 @@ No class forward/backward compatibility are supported in this mode.
 </p>
 
 #### Java schema compatible deserialization
+
 The deserialization peer can have different class definition with the serialization peer.
 Class forward/backward compatibility are supported in this mode.
 <p align="center">
@@ -135,10 +160,13 @@ Class forward/backward compatibility are supported in this mode.
 </p>
 
 ### Zero-copy serialization
-Note that zero-copy serialization just avoid the copy in serialization, if you send data to other machine, there may be copies. 
+
+Note that zero-copy serialization just avoid the copy in serialization, if you send data to other machine, there may be copies.
 
 But if you serialize data between processes on same node and use shared-memory, if the data are in off-heap before serialization, then other processes can read this buffer without any copies.
+
 #### Java zero-copy serialize to heap buffer
+
 <p align="center">
 <img width="24%" alt="" src="zerocopy/zero_copy_bench_serialize_BUFFER_to_array_tps.png">
 <img width="24%" alt="" src="zerocopy/zero_copy_bench_serialize_BUFFER_to_directBuffer_tps.png">
@@ -147,6 +175,7 @@ But if you serialize data between processes on same node and use shared-memory,
 </p>
 
 #### Java zero-copy serialize to direct buffer
+
 <p align="center">
 <img width="24%" alt="" src="zerocopy/zero_copy_bench_deserialize_BUFFER_from_array_tps.png">
 <img width="24%" alt="" src="zerocopy/zero_copy_bench_deserialize_BUFFER_from_directBuffer_tps.png">
@@ -155,7 +184,9 @@ But if you serialize data between processes on same node and use shared-memory,
 </p>
 
 ## Benchmark Data
+
 ### Java Serialization
+
 | Lib | Benchmark | bufferType | objectType | references | Tps |
 | ------- | ------- | ------- | ------- | ------- | ------- |
 | Fst | serialize | array | SAMPLE | False | 915907.574306 |
@@ -464,6 +495,7 @@ But if you serialize data between processes on same node and use shared-memory,
 | Protostuff | deserialize | directBuffer | STRUCT2 | False | 425523.315814 |
 
 ### Java Zero-copy
+
 | Lib | Benchmark | array_size | bufferType | dataType | Tps |
 | ------- | ------- | ------- | ------- | ------- | ------- |
 | Fst | deserialize | 200 | array | PRIMITIVE_ARRAY | 219333.990504 |
diff --git a/docs/cpp_debug.md b/docs/cpp_debug.md
index 284eff4002..e408a1bc65 100644
--- a/docs/cpp_debug.md
+++ b/docs/cpp_debug.md
@@ -1,12 +1,12 @@
 # Debugging C++
 
-Debug C++ is tricky and binary protocol bug is hard to locate without debugging support, but setup 
+Debug C++ is tricky and binary protocol bug is hard to locate without debugging support, but setup
 debugging support for bazel project is not easy.
 
 Fury include an out-of-box `launch.json/tasks.json` config in `.vocode` directory for c++ debugging.
 
 Just open the fury root directory in vscode, then open a test file such as `src/fury/row/row_test.cc`,
-enter `F5`, then you can debug the c++ code line by line, watch variables, add breakpoints in vscode just like 
+enter `F5`, then you can debug the c++ code line by line, watch variables, add breakpoints in vscode just like
 java/python debugging.
 
 <img src="images/vscode_debug_fury.jpg" alt="Fury Debugging Example" width="50%" height="50%" />
@@ -14,10 +14,10 @@ java/python debugging.
 ## Notes
 
 - For Macos: Install `CodeLLDB` vscode plugin
-- For Linux: 
+- For Linux:
   - install gdb for fedora/centos by `sudo yum install -y gdb`
   - install gdb for fedora/centos by `sudo apt-get install gdb`
-- If debugging doesn't work, please select correct debug/run options: 
+- If debugging doesn't work, please select correct debug/run options:
   <img src="images/vscode_select_debug_run.png" alt="select correct debug/run options" width="50%" height="50%" />
-- Debug will jump to source files in bazel generated directory, we need to return raw files in source tree 
+- Debug will jump to source files in bazel generated directory, we need to return raw files in source tree
 for debugging again: <img src="images/jmp_generate_file.png" alt="jump to generated files" width="50%" height="50%" />
diff --git a/docs/guide/DEVELOPMENT.md b/docs/guide/DEVELOPMENT.md
index 3949dcb58f..5cbdd86822 100644
--- a/docs/guide/DEVELOPMENT.md
+++ b/docs/guide/DEVELOPMENT.md
@@ -4,7 +4,7 @@ sidebar_position: 7
 id: development
 ---
 
-# How to build Fury
+## How to build Fury
 
 Please checkout the source tree from https://github.com/apache/fury.
 
@@ -99,4 +99,3 @@ npm run test
 
 - node 14+
 - npm 8+
-
diff --git a/docs/guide/graalvm_guide.md b/docs/guide/graalvm_guide.md
index 3ed919fd05..afaaa15f78 100644
--- a/docs/guide/graalvm_guide.md
+++ b/docs/guide/graalvm_guide.md
@@ -4,7 +4,8 @@ sidebar_position: 6
 id: graalvm_guide
 ---
 
-# GraalVM Native Image
+## GraalVM Native Image
+
 GraalVM `native image` can compile java code into native code ahead to build faster, smaller, leaner applications.
 The native image doesn't have a JIT compiler to compile bytecode into machine code, and doesn't support
 reflection unless configure reflection file.
@@ -16,6 +17,7 @@ In order to use Fury on graalvm native image, you must create Fury as an **stati
  the enclosing class initialize time. Then configure `native-image.properties` under
 `resources/META-INF/native-image/$xxx/native-image.propertie` to tell graalvm to init the class at native image
 build time. For example, here we configure `org.apache.fury.graalvm.Example` class be init at build time:
+
 ```properties
 Args = --initialize-at-build-time=org.apache.fury.graalvm.Example
 ```
@@ -29,7 +31,9 @@ Note that Fury `asyncCompilationEnabled` option will be disabled automatically f
 native image doesn't support JIT at the image run time.
 
 ## Not thread-safe Fury
+
 Example:
+
 ```java
 import org.apache.fury.Fury;
 import org.apache.fury.util.Preconditions;
@@ -63,12 +67,15 @@ public class Example {
   }
 }
 ```
+
 Then add `org.apache.fury.graalvm.Example` build time init to `native-image.properties` configuration:
+
 ```properties
 Args = --initialize-at-build-time=org.apache.fury.graalvm.Example
 ```
 
 ## Thread-safe Fury
+
 ```java
 import org.apache.fury.Fury;
 import org.apache.fury.ThreadLocalFury;
@@ -109,32 +116,40 @@ public class ThreadSafeExample {
   }
 }
 ```
+
 Then add `org.apache.fury.graalvm.ThreadSafeExample` build time init to `native-image.properties` configuration:
+
 ```properties
 Args = --initialize-at-build-time=org.apache.fury.graalvm.ThreadSafeExample
 ```
 
 ## Framework Integration
+
 For framework developers, if you want to integrate fury for serialization, you can provided a configuration file to let
 the users to list all the classes they want to serialize, then you can load those classes and invoke
 `org.apache.fury.Fury.register(Class<?>, boolean)` to register those classes in your Fury integration class, and configure that
 class be initialized at graalvm native image build time.
 
 ## Benchmark
+
 Here we give two class benchmarks between Fury and Graalvm Serialization.
 
 When Fury compression is disabled:
+
 - Struct: Fury is `46x speed, 43% size` compared to JDK.
 - Pojo: Fury is `12x speed, 56% size` compared to JDK.
 
 When Fury compression is enabled:
+
 - Struct: Fury is `24x speed, 31% size` compared to JDK.
 - Pojo: Fury is `12x speed, 48% size` compared to JDK.
 
 See [[Benchmark.java](https://github.com/apache/fury/blob/main/integration_tests/graalvm_tests/src/main/java/org/apache/fury/graalvm/Benchmark.java)] for benchmark code.
 
 ### Struct Benchmark
+
 #### Class Fields
+
 ```java
 public class Struct implements Serializable {
   public int f1;
@@ -151,8 +166,11 @@ public class Struct implements Serializable {
   public double f12;
 }
 ```
+
 #### Benchmark Results
+
 No compression:
+
 ```
 Benchmark repeat number: 400000
 Object type: class org.apache.fury.graalvm.Struct
@@ -164,7 +182,9 @@ JDK serialization took mills: 2254
 Compare speed: Fury is 45.70x speed of JDK
 Compare size: Fury is 0.43x size of JDK
 ```
+
 Compress number:
+
 ```
 Benchmark repeat number: 400000
 Object type: class org.apache.fury.graalvm.Struct
@@ -178,7 +198,9 @@ Compare size: Fury is 0.31x size of JDK
 ```
 
 ### Pojo Benchmark
+
 #### Class Fields
+
 ```java
 public class Foo implements Serializable {
   int f1;
@@ -187,8 +209,11 @@ public class Foo implements Serializable {
   Map<String, Long> f4;
 }
 ```
+
 #### Benchmark Results
+
 No compression:
+
 ```
 Benchmark repeat number: 400000
 Object type: class org.apache.fury.graalvm.Foo
@@ -200,7 +225,9 @@ JDK serialization took mills: 16266
 Compare speed: Fury is 12.19x speed of JDK
 Compare size: Fury is 0.56x size of JDK
 ```
+
 Compress number:
+
 ```
 Benchmark repeat number: 400000
 Object type: class org.apache.fury.graalvm.Foo
diff --git a/docs/guide/java_serialization_guide.md b/docs/guide/java_serialization_guide.md
index de179f417e..3d8522b548 100644
--- a/docs/guide/java_serialization_guide.md
+++ b/docs/guide/java_serialization_guide.md
@@ -4,7 +4,7 @@ sidebar_position: 0
 id: java_object_graph_guide
 ---
 
-# Java object graph serialization
+## Java object graph serialization
 
 When only java object serialization needed, this mode will have better performance compared to cross-language object
 graph serialization.
@@ -179,12 +179,12 @@ bit is set, then next byte will be read util first bit of next byte is unset.
 For long compression, fury support two encoding:
 
 - Fury SLI(Small long as int) Encoding (**used by default**):
-    - If long is in [-1073741824, 1073741823], encode as 4 bytes int: `| little-endian: ((int) value) << 1 |`
-    - Otherwise write as 9 bytes: `| 0b1 | little-endian 8bytes long |`
+  - If long is in [-1073741824, 1073741823], encode as 4 bytes int: `| little-endian: ((int) value) << 1 |`
+  - Otherwise write as 9 bytes: `| 0b1 | little-endian 8bytes long |`
 - Fury PVL(Progressive Variable-length Long) Encoding:
-    - First bit in every byte indicate whether has next byte. if first bit is set, then next byte will be read util
+  - First bit in every byte indicate whether has next byte. if first bit is set, then next byte will be read util
       first bit of next byte is unset.
-    - Negative number will be converted to positive number by ` (v << 1) ^ (v >> 63)` to reduce cost of small negative
+  - Negative number will be converted to positive number by `(v << 1) ^ (v >> 63)` to reduce cost of small negative
       numbers.
 
 If a number are `long` type, it can't be represented by smaller bytes mostly, the compression won't get good enough
diff --git a/docs/guide/row_format_guide.md b/docs/guide/row_format_guide.md
index 076a2c0638..108329724d 100644
--- a/docs/guide/row_format_guide.md
+++ b/docs/guide/row_format_guide.md
@@ -5,7 +5,9 @@ id: row_format_guide
 ---
 
 ## Row format protocol
+
 ### Java
+
 ```java
 public class Bar {
   String f1;
@@ -50,7 +52,9 @@ RowEncoder<Bar> barEncoder = Encoders.bean(Bar.class);
 Bar newBar = barEncoder.fromRow(barStruct);
 Bar newBar2 = barEncoder.fromRow(binaryArray4.getStruct(20));
 ```
+
 ### Python
+
 ```python
 @dataclass
 class Bar:
@@ -79,10 +83,13 @@ new_foo = pickle.loads(binary)
 print(new_foo.f2[100000], new_foo.f4[100000].f1, new_foo.f4[200000].f2[5])
 print(f"pickle end: {datetime.datetime.now()}")
 ```
+
 ### Apache Arrow Support
+
 Fury Format also supports automatic conversion from/to Arrow Table/RecordBatch.
 
 Java:
+
 ```java
 Schema schema = TypeInference.inferSchema(BeanA.class);
 ArrowWriter arrowWriter = ArrowUtils.createArrowWriter(schema);
@@ -93,14 +100,18 @@ for (int i = 0; i < 10; i++) {
 }
 return arrowWriter.finishAsRecordBatch();
 ```
+
 Python:
+
 ```python
 import pyfury
 encoder = pyfury.encoder(Foo)
 encoder.to_arrow_record_batch([foo] * 10000)
 encoder.to_arrow_table([foo] * 10000)
 ```
+
 C++
+
 ```c++
 std::shared_ptr<ArrowWriter> arrow_writer;
 EXPECT_TRUE(
@@ -115,6 +126,7 @@ EXPECT_TRUE(record_batch->Validate().ok());
 EXPECT_EQ(record_batch->num_columns(), schema->num_fields());
 EXPECT_EQ(record_batch->num_rows(), row_nums);
 ```
+
 ```java
 Schema schema = TypeInference.inferSchema(BeanA.class);
 ArrowWriter arrowWriter = ArrowUtils.createArrowWriter(schema);
diff --git a/docs/guide/scala_guide.md b/docs/guide/scala_guide.md
index aa8f99beaa..4de2f099a2 100644
--- a/docs/guide/scala_guide.md
+++ b/docs/guide/scala_guide.md
@@ -4,8 +4,8 @@ sidebar_position: 4
 id: scala_guide
 ---
 
-# Scala serialization
 Fury supports all scala object serialization:
+
 - `case` class serialization supported
 - `pojo/bean` class serialization supported
 - `object` singleton serialization supported
@@ -15,12 +15,15 @@ Fury supports all scala object serialization:
 Scala 2 and 3 are both supported.
 
 ## Install
+
 ```sbt
 libraryDependencies += "org.apache.fury" % "fury-core" % "0.7.0"
 ```
 
 ## Fury creation
+
 When using fury for scala serialization, you should create fury at least with following options:
+
 ```scala
 val fury = Fury.builder()
   .withScalaOptimizationEnabled(true)
@@ -28,11 +31,14 @@ val fury = Fury.builder()
   .withRefTracking(true)
   .build()
 ```
+
 Depending on the object types you serialize, you may need to register some scala internal types:
+
 ```scala
 fury.register(Class.forName("scala.collection.generic.DefaultSerializationProxy"))
 fury.register(Class.forName("scala.Enumeration.Val"))
 ```
+
 If you want to avoid such registration, you can disable class registration by `FuryBuilder#requireClassRegistration(false)`.
 Note that this option allow to deserialize objects unknown types, more flexible but may be insecure if the classes contains malicious code.
 
@@ -43,6 +49,7 @@ Note that fury instance should be shared between multiple serialization, the cre
 If you use shared fury instance across multiple threads, you should create `ThreadSafeFury` instead by `FuryBuilder#buildThreadSafeFury()` instead.
 
 ## Serialize case object
+
 ```scala
 case class Person(github: String, age: Int, id: Long)
 val p = Person("https://github.com/chaokunyang", 18, 1)
@@ -51,6 +58,7 @@ println(fury.deserializeJavaObject(fury.serializeJavaObject(p)))
 ```
 
 ## Serialize pojo
+
 ```scala
 class Foo(f1: Int, f2: String) {
   override def toString: String = s"Foo($f1, $f2)"
@@ -59,6 +67,7 @@ println(fury.deserialize(fury.serialize(Foo(1, "chaokunyang"))))
 ```
 
 ## Serialize object singleton
+
 ```scala
 object singleton {
 }
@@ -68,6 +77,7 @@ println(o1 == o2)
 ```
 
 ## Serialize collection
+
 ```scala
 val seq = Seq(1,2)
 val list = List("a", "b")
@@ -78,6 +88,7 @@ println(fury.deserialize(fury.serialize(map)))
 ```
 
 ## Serialize Tuple
+
 ```scala
 val tuple = Tuple2(100, 10000L)
 println(fury.deserialize(fury.serialize(tuple)))
@@ -86,12 +97,16 @@ println(fury.deserialize(fury.serialize(tuple)))
 ```
 
 ## Serialize Enum
+
 ### Scala3 Enum
+
 ```scala
 enum Color { case Red, Green, Blue }
 println(fury.deserialize(fury.serialize(Color.Green)))
 ```
+
 ### Scala2 Enum
+
 ```scala
 object ColorEnum extends Enumeration {
   type ColorEnum = Value
@@ -101,6 +116,7 @@ println(fury.deserialize(fury.serialize(ColorEnum.Green)))
 ```
 
 ## Serialize Option
+
 ```scala
 val opt: Option[Long] = Some(100)
 println(fury.deserialize(fury.serialize(opt)))
@@ -108,7 +124,8 @@ val opt1: Option[Long] = None
 println(fury.deserialize(fury.serialize(opt1)))
 ```
 
-# Performance
+## Performance
+
 Scala `pojo/bean/case/object` are supported by fury jit well, the performance is as good as fury java.
 
 Scala collections and generics doesn't follow java collection framework, and is not fully integrated with Fury JIT in current release version. The performance won't be as good as fury collections serialization for java.
diff --git a/docs/guide/xlang_serialization_guide.md b/docs/guide/xlang_serialization_guide.md
index a68348e310..5bc6a0551b 100644
--- a/docs/guide/xlang_serialization_guide.md
+++ b/docs/guide/xlang_serialization_guide.md
@@ -7,8 +7,8 @@ id: xlang_object_graph_guide
 ## Cross-language object graph serialization
 
 ### Serialize built-in types
-Common types can be serialized automatically: primitive numeric types, string, binary, array, list, map and so on.
 
+Common types can be serialized automatically: primitive numeric types, string, binary, array, list, map and so on.
 
 **Java**
 
@@ -64,32 +64,32 @@ import furygo "github.com/apache/fury/fury/go/fury"
 import "fmt"
 
 func main() {
-	list := []interface{}{true, false, "str", -1.1, 1, make([]int32, 10), make([]float64, 20)}
-	fury := furygo.NewFury()
-	bytes, err := fury.Marshal(list)
-	if err != nil {
-		panic(err)
-	}
-	var newValue interface{}
-	// bytes can be data serialized by other languages.
-	if err := fury.Unmarshal(bytes, &newValue); err != nil {
-		panic(err)
-	}
-	fmt.Println(newValue)
-	dict := map[string]interface{}{
-		"k1": "v1",
-		"k2": list,
-		"k3": -1,
-	}
-	bytes, err = fury.Marshal(dict)
-	if err != nil {
-		panic(err)
-	}
-	// bytes can be data serialized by other languages.
-	if err := fury.Unmarshal(bytes, &newValue); err != nil {
-		panic(err)
-	}
-	fmt.Println(newValue)
+ list := []interface{}{true, false, "str", -1.1, 1, make([]int32, 10), make([]float64, 20)}
+ fury := furygo.NewFury()
+ bytes, err := fury.Marshal(list)
+ if err != nil {
+  panic(err)
+ }
+ var newValue interface{}
+ // bytes can be data serialized by other languages.
+ if err := fury.Unmarshal(bytes, &newValue); err != nil {
+  panic(err)
+ }
+ fmt.Println(newValue)
+ dict := map[string]interface{}{
+  "k1": "v1",
+  "k2": list,
+  "k3": -1,
+ }
+ bytes, err = fury.Marshal(dict)
+ if err != nil {
+  panic(err)
+ }
+ // bytes can be data serialized by other languages.
+ if err := fury.Unmarshal(bytes, &newValue); err != nil {
+  panic(err)
+ }
+ fmt.Println(newValue)
 }
 ```
 
@@ -126,6 +126,7 @@ fn run() {
 ```
 
 ### Serialize custom types
+
 Serializing user-defined types needs registering the custom type using the register API to establish the mapping relationship between the type in different languages.
 
 **Java**
@@ -255,59 +256,59 @@ import furygo "github.com/apache/fury/fury/go/fury"
 import "fmt"
 
 func main() {
-	type SomeClass1 struct {
-		F1  interface{}
-		F2  string
-		F3  []interface{}
-		F4  map[int8]int32
-		F5  int8
-		F6  int16
-		F7  int32
-		F8  int64
-		F9  float32
-		F10 float64
-		F11 []int16
-		F12 fury.Int16Slice
-	}
-
-	type SomeClas2 struct {
-		F1 interface{}
-		F2 map[int8]int32
-	}
-	fury := furygo.NewFury()
-	if err := fury.RegisterTagType("example.SomeClass1", SomeClass1{}); err != nil {
-		panic(err)
-	}
-	if err := fury.RegisterTagType("example.SomeClass2", SomeClass2{}); err != nil {
-		panic(err)
-	}
-	obj1 := &SomeClass1{}
-	obj1.F1 = true
-	obj1.F2 = map[int8]int32{-1: 2}
-	obj := &SomeClass1{}
-	obj.F1 = obj1
-	obj.F2 = "abc"
-	obj.F3 = []interface{}{"abc", "abc"}
-	f4 := map[int8]int32{1: 2}
-	obj.F4 = f4
-	obj.F5 = fury.MaxInt8
-	obj.F6 = fury.MaxInt16
-	obj.F7 = fury.MaxInt32
-	obj.F8 = fury.MaxInt64
-	obj.F9 = 1.0 / 2
-	obj.F10 = 1 / 3.0
-	obj.F11 = []int16{1, 2}
-	obj.F12 = []int16{-1, 4}
-	bytes, err := fury.Marshal(obj);
-	if err != nil {
-		panic(err)
-	}
-	var newValue interface{}
-	// bytes can be data serialized by other languages.
-	if err := fury.Unmarshal(bytes, &newValue); err != nil {
-		panic(err)
-	}
-	fmt.Println(newValue)
+ type SomeClass1 struct {
+  F1  interface{}
+  F2  string
+  F3  []interface{}
+  F4  map[int8]int32
+  F5  int8
+  F6  int16
+  F7  int32
+  F8  int64
+  F9  float32
+  F10 float64
+  F11 []int16
+  F12 fury.Int16Slice
+ }
+
+ type SomeClas2 struct {
+  F1 interface{}
+  F2 map[int8]int32
+ }
+ fury := furygo.NewFury()
+ if err := fury.RegisterTagType("example.SomeClass1", SomeClass1{}); err != nil {
+  panic(err)
+ }
+ if err := fury.RegisterTagType("example.SomeClass2", SomeClass2{}); err != nil {
+  panic(err)
+ }
+ obj1 := &SomeClass1{}
+ obj1.F1 = true
+ obj1.F2 = map[int8]int32{-1: 2}
+ obj := &SomeClass1{}
+ obj.F1 = obj1
+ obj.F2 = "abc"
+ obj.F3 = []interface{}{"abc", "abc"}
+ f4 := map[int8]int32{1: 2}
+ obj.F4 = f4
+ obj.F5 = fury.MaxInt8
+ obj.F6 = fury.MaxInt16
+ obj.F7 = fury.MaxInt32
+ obj.F8 = fury.MaxInt64
+ obj.F9 = 1.0 / 2
+ obj.F10 = 1 / 3.0
+ obj.F11 = []int16{1, 2}
+ obj.F12 = []int16{-1, 4}
+ bytes, err := fury.Marshal(obj);
+ if err != nil {
+  panic(err)
+ }
+ var newValue interface{}
+ // bytes can be data serialized by other languages.
+ if err := fury.Unmarshal(bytes, &newValue); err != nil {
+  panic(err)
+ }
+ fmt.Println(newValue)
 }
 ```
 
@@ -394,6 +395,7 @@ fn complex_struct() {
 ```
 
 ### Serialize Shared Reference and Circular Reference
+
 Shared reference and circular reference can be serialized automatically, no duplicate data or recursion error.
 
 **Java**
@@ -460,27 +462,27 @@ import furygo "github.com/apache/fury/fury/go/fury"
 import "fmt"
 
 func main() {
-	type SomeClass struct {
-		F1 *SomeClass
-		F2 map[string]string
-		F3 map[string]string
-	}
-	fury := furygo.NewFury(true)
-	if err := fury.RegisterTagType("example.SomeClass", SomeClass{}); err != nil {
-		panic(err)
-	}
-	value := &SomeClass{F2: map[string]string{"k1": "v1", "k2": "v2"}}
-	value.F3 = value.F2
-	value.F1 = value
-	bytes, err := fury.Marshal(value)
-	if err != nil {
-	}
-	var newValue interface{}
-	// bytes can be data serialized by other languages.
-	if err := fury.Unmarshal(bytes, &newValue); err != nil {
-		panic(err)
-	}
-	fmt.Println(newValue)
+ type SomeClass struct {
+  F1 *SomeClass
+  F2 map[string]string
+  F3 map[string]string
+ }
+ fury := furygo.NewFury(true)
+ if err := fury.RegisterTagType("example.SomeClass", SomeClass{}); err != nil {
+  panic(err)
+ }
+ value := &SomeClass{F2: map[string]string{"k1": "v1", "k2": "v2"}}
+ value.F3 = value.F2
+ value.F1 = value
+ bytes, err := fury.Marshal(value)
+ if err != nil {
+ }
+ var newValue interface{}
+ // bytes can be data serialized by other languages.
+ if err := fury.Unmarshal(bytes, &newValue); err != nil {
+  panic(err)
+ }
+ fmt.Println(newValue)
 }
 ```
 
@@ -514,7 +516,6 @@ console.log(result.bar.foo === result.foo);
 **JavaScript**
 Reference cannot be implemented because of rust ownership restrictions
 
-
 ### Zero-Copy Serialization
 
 **Java**
@@ -569,23 +570,23 @@ import furygo "github.com/apache/fury/fury/go/fury"
 import "fmt"
 
 func main() {
-	fury := furygo.NewFury()
-	list := []interface{}{"str", make([]byte, 1000)}
-	buf := fury.NewByteBuffer(nil)
-	var bufferObjects []fury.BufferObject
-	fury.Serialize(buf, list, func(o fury.BufferObject) bool {
-		bufferObjects = append(bufferObjects, o)
-		return false
-	})
-	var newList []interface{}
-	var buffers []*fury.ByteBuffer
-	for _, o := range bufferObjects {
-		buffers = append(buffers, o.ToBuffer())
-	}
-	if err := fury.Deserialize(buf, &newList, buffers); err != nil {
-		panic(err)
-	}
-	fmt.Println(newList)
+ fury := furygo.NewFury()
+ list := []interface{}{"str", make([]byte, 1000)}
+ buf := fury.NewByteBuffer(nil)
+ var bufferObjects []fury.BufferObject
+ fury.Serialize(buf, list, func(o fury.BufferObject) bool {
+  bufferObjects = append(bufferObjects, o)
+  return false
+ })
+ var newList []interface{}
+ var buffers []*fury.ByteBuffer
+ for _, o := range bufferObjects {
+  buffers = append(buffers, o.ToBuffer())
+ }
+ if err := fury.Deserialize(buf, &newList, buffers); err != nil {
+  panic(err)
+ }
+ fmt.Println(newList)
 }
 ```
 
diff --git a/docs/guide/xlang_type_mapping.md b/docs/guide/xlang_type_mapping.md
index 4baa45534f..43c7e3c961 100644
--- a/docs/guide/xlang_type_mapping.md
+++ b/docs/guide/xlang_type_mapping.md
@@ -10,7 +10,7 @@ Note:
 - `int16_t[n]/vector<T>` indicates `int16_t[n]/vector<int16_t>`
 - The cross-language serialization is not stable, do not use it in your production environment.
 
-# Type Mapping
+## Type Mapping
 
 | Fury Type          | Fury Type ID | Java            | Python               | Javascript      | C++                            | Golang           | Rust             |
 |--------------------|--------------|-----------------|----------------------|-----------------|--------------------------------|------------------|------------------|
@@ -48,7 +48,7 @@ Note:
 | arrow record batch | 32           | /               | /                    | /               | /                              | /                | /                |
 | arrow table        | 33           | /               | /                    | /               | /                              | /                | /                |
 
-# Type info(not implemented currently)
+## Type info(not implemented currently)
 
 Due to differences between type systems of languages, those types can't be mapped one-to-one between languages.
 
@@ -70,6 +70,7 @@ Such information can be provided in other languages too:
 Here is en example:
 
 - Java:
+
     ```java
     class Foo {
       @Int32Type(varint = true)
@@ -77,6 +78,7 @@ Here is en example:
       List<@Int32Type(varint = true) Integer> f2;
     }
     ```
+
 - Python:
 
     ```python
diff --git a/docs/specification/java_serialization_spec.md b/docs/specification/java_serialization_spec.md
index 592413a442..a23572590a 100644
--- a/docs/specification/java_serialization_spec.md
+++ b/docs/specification/java_serialization_spec.md
@@ -4,8 +4,6 @@ sidebar_position: 1
 id: fury_java_serialization_spec
 ---
 
-# Fury Java Serialization Specification
-
 ## Spec overview
 
 Fury Java Serialization is an automatic object serialization framework that supports reference and polymorphism. Fury
@@ -77,14 +75,14 @@ If schema consistent mode is enabled globally or enabled for current class, clas
 
 - If class is registered, it will be written as a fury unsigned varint: `class_id << 1`.
 - If class is not registered:
-    - If class is not an array, fury will write one byte `0bxxxxxxx1` first, then write class name.
-        - The first little bit is `1`, which is different from first bit `0` of
+  - If class is not an array, fury will write one byte `0bxxxxxxx1` first, then write class name.
+    - The first little bit is `1`, which is different from first bit `0` of
           encoded class id. Fury can use this information to determine whether to read class by class id for
           deserialization.
-    - If class is not registered and class is an array, fury will write one byte `dimensions << 1 | 1` first, then write
+  - If class is not registered and class is an array, fury will write one byte `dimensions << 1 | 1` first, then write
       component
       class subsequently. This can reduce array class name cost if component class is or will be serialized.
-    - Class will be written as two enumerated fury unsigned by default: `package name` and `class name`. If meta share
+  - Class will be written as two enumerated fury unsigned by default: `package name` and `class name`. If meta share
       mode is
       enabled,
       class will be written as an unsigned varint which points to index in `MetaContext`.
@@ -145,10 +143,10 @@ Meta header is a 64 bits number value encoded in little endian order.
 ```
 
 - num fields: encode `num fields << 1 | register flag(1 when class registered)` as unsigned varint.
-    - If class is registered, then an unsigned varint class id will be written next, package and class name will be
+  - If class is registered, then an unsigned varint class id will be written next, package and class name will be
       omitted.
-    - If current class is schema consistent, then num field will be `0` to flag it.
-    - If current class isn't schema consistent, then num field will be the number of compatible fields. For example,
+  - If current class is schema consistent, then num field will be `0` to flag it.
+  - If current class isn't schema consistent, then num field will be the number of compatible fields. For example,
       users
       can use tag id to mark some field as compatible field in schema consistent context. In such cases, schema
       consistent
@@ -156,34 +154,34 @@ Meta header is a 64 bits number value encoded in little endian order.
       fields info of those fields which aren't annotated by tag id for deserializing schema consistent fields, then use
       fields info in meta for deserializing compatible fields.
 - Package name encoding(omitted when class is registered):
-    - encoding algorithm: `UTF8/ALL_TO_LOWER_SPECIAL/LOWER_UPPER_DIGIT_SPECIAL`
-    - Header: `6 bits size | 2 bits encoding flags`. The `6 bits size: 0~63`  will be used to indicate size `0~62`,
+  - encoding algorithm: `UTF8/ALL_TO_LOWER_SPECIAL/LOWER_UPPER_DIGIT_SPECIAL`
+  - Header: `6 bits size | 2 bits encoding flags`. The `6 bits size: 0~63`  will be used to indicate size `0~62`,
       the value `63` the size need more byte to read, the encoding will encode `size - 62` as a varint next.
 - Class name encoding(omitted when class is registered):
-    - encoding algorithm: `UTF8/LOWER_UPPER_DIGIT_SPECIAL/FIRST_TO_LOWER_SPECIAL/ALL_TO_LOWER_SPECIAL`
-    - header: `6 bits size | 2 bits encoding flags`. The `6 bits size: 0~63`  will be used to indicate size `1~64`,
+  - encoding algorithm: `UTF8/LOWER_UPPER_DIGIT_SPECIAL/FIRST_TO_LOWER_SPECIAL/ALL_TO_LOWER_SPECIAL`
+  - header: `6 bits size | 2 bits encoding flags`. The `6 bits size: 0~63`  will be used to indicate size `1~64`,
       the value `63` the size need more byte to read, the encoding will encode `size - 63` as a varint next.
 - Field info:
-    - header(8
+  - header(8
       bits): `3 bits size + 2 bits field name encoding + polymorphism flag + nullability flag + ref tracking flag`.
       Users can use annotation to provide those info.
-        - 2 bits field name encoding:
-            - encoding: `UTF8/ALL_TO_LOWER_SPECIAL/LOWER_UPPER_DIGIT_SPECIAL/TAG_ID`
-            - If tag id is used, i.e. field name is written by an unsigned varint tag id. 2 bits encoding will be `11`.
-        - size of field name:
-            - The `3 bits size: 0~7`  will be used to indicate length `1~7`, the value `6` the size read more bytes,
+    - 2 bits field name encoding:
+      - encoding: `UTF8/ALL_TO_LOWER_SPECIAL/LOWER_UPPER_DIGIT_SPECIAL/TAG_ID`
+      - If tag id is used, i.e. field name is written by an unsigned varint tag id. 2 bits encoding will be `11`.
+    - size of field name:
+      - The `3 bits size: 0~7`  will be used to indicate length `1~7`, the value `6` the size read more bytes,
               the encoding will encode `size - 7` as a varint next.
-            - If encoding is `TAG_ID`, then num_bytes of field name will be used to store tag id.
-        - ref tracking: when set to 1, ref tracking will be enabled for this field.
-        - nullability: when set to 1, this field can be null.
-        - polymorphism: when set to 1, the actual type of field will be the declared field type even the type if
+      - If encoding is `TAG_ID`, then num_bytes of field name will be used to store tag id.
+    - ref tracking: when set to 1, ref tracking will be enabled for this field.
+    - nullability: when set to 1, this field can be null.
+    - polymorphism: when set to 1, the actual type of field will be the declared field type even the type if
           not `final`.
-    - type id:
-        - For registered type-consistent classes, it will be the registered class id.
-        - Otherwise it will be encoded as `OBJECT_ID` if it isn't `final` and `FINAL_OBJECT_ID` if it's `final`. The
+  - type id:
+    - For registered type-consistent classes, it will be the registered class id.
+    - Otherwise it will be encoded as `OBJECT_ID` if it isn't `final` and `FINAL_OBJECT_ID` if it's `final`. The
           meta for such types is written separately instead of inlining here is to reduce meta space cost if object of
           this type is serialized in current object graph multiple times, and the field value may be null too.
-    - Field name: If type id is set, type id will be used instead. Otherwise meta string encoding length and data will
+  - Field name: If type id is set, type id will be used instead. Otherwise meta string encoding length and data will
       be written instead.
 
 Field order are left as implementation details, which is not exposed to specification, the deserialization need to
@@ -195,12 +193,12 @@ using a more compact encoding.
 Same encoding algorithm as the previous layer except:
 
 - header + package name:
-    - Header:
-        - If package name has been written before: `varint index + sharing flag(set)` will be written
-        - If package name hasn't been written before:
-            - If meta string encoding is `LOWER_SPECIAL` and the length of encoded string `<=` 64, then header will be
+  - Header:
+    - If package name has been written before: `varint index + sharing flag(set)` will be written
+    - If package name hasn't been written before:
+      - If meta string encoding is `LOWER_SPECIAL` and the length of encoded string `<=` 64, then header will be
               `6 bits size + encoding flag(set) + sharing flag(unset)`.
-            - Otherwise, header will
+      - Otherwise, header will
               be `3 bits unset + 3 bits encoding flags + encoding flag(unset) + sharing flag(unset)`
 
 ## Meta String
@@ -307,17 +305,17 @@ If string has been written before, the data will be written as follows:
 
 - size: 1~9 byte
 - Fury PVL(Progressive Variable-length Long) Encoding:
-    - positive long format: first bit in every byte indicates whether to have the next byte. If first bit is set
+  - positive long format: first bit in every byte indicates whether to have the next byte. If first bit is set
       i.e. `b & 0x80 == 0x80`, then the next byte should be read until the first bit is unset.
 
 #### Signed long
 
 - size: 1~9 byte
 - Fury SLI(Small long as int) Encoding:
-    - If long is in [-1073741824, 1073741823], encode as 4 bytes int: `| little-endian: ((int) value) << 1 |`
-    - Otherwise write as 9 bytes: `| 0b1 | little-endian 8 bytes long |`
+  - If long is in [-1073741824, 1073741823], encode as 4 bytes int: `| little-endian: ((int) value) << 1 |`
+  - Otherwise write as 9 bytes: `| 0b1 | little-endian 8 bytes long |`
 - Fury PVL(Progressive Variable-length Long) Encoding:
-    - First convert the number into positive unsigned long by ` (v << 1) ^ (v >> 63)` ZigZag algorithm to reduce cost of
+  - First convert the number into positive unsigned long by `(v << 1) ^ (v >> 63)` ZigZag algorithm to reduce cost of
       small negative numbers, then encoding it as an unsigned long.
 
 #### Float
diff --git a/docs/specification/row_format_spec.md b/docs/specification/row_format_spec.md
index d32c11abfb..f368eb75fb 100644
--- a/docs/specification/row_format_spec.md
+++ b/docs/specification/row_format_spec.md
@@ -4,5 +4,6 @@ sidebar_position: 2
 id: fury_row_format_spec
 ---
 
-# Row Format
+## Row Format
+
 Coming soon
diff --git a/docs/specification/xlang_serialization_spec.md b/docs/specification/xlang_serialization_spec.md
index 5882d00991..7fd991ceb9 100644
--- a/docs/specification/xlang_serialization_spec.md
+++ b/docs/specification/xlang_serialization_spec.md
@@ -4,9 +4,10 @@ sidebar_position: 0
 id: fury_xlang_serialization_spec
 ---
 
-# Cross-language Serialization Specification
+## Cross-language Serialization Specification
 
 > Format Version History:
+>
 > - Version 0.1 - serialization spec formalized
 
 Fury xlang serialization is an automatic object serialization framework that supports reference and polymorphism.
@@ -42,22 +43,22 @@ also introduce more complexities compared to static serialization frameworks. So
 - set: an unordered set of unique elements.
 - map: a map of key-value pairs. Mutable types such as `list/map/set/array/tensor/arrow` are not allowed as key of map.
 - time types:
-    - duration: an absolute length of time, independent of any calendar/timezone, as a count of nanoseconds.
-    - timestamp: a point in time, independent of any calendar/timezone, as a count of nanoseconds. The count is relative
+  - duration: an absolute length of time, independent of any calendar/timezone, as a count of nanoseconds.
+  - timestamp: a point in time, independent of any calendar/timezone, as a count of nanoseconds. The count is relative
       to an epoch at UTC midnight on January 1, 1970.
 - decimal: exact decimal value represented as an integer value in two's complement.
 - binary: an variable-length array of bytes.
 - array type: only allow numeric components. Other arrays will be taken as List. The implementation should support the
   interoperability between array and list.
-    - array: multidimensional array which every sub-array can have different sizes but all have same type.
-    - bool_array: one dimensional int16 array.
-    - int8_array: one dimensional int8 array.
-    - int16_array: one dimensional int16 array.
-    - int32_array: one dimensional int32 array.
-    - int64_array: one dimensional int64 array.
-    - float16_array: one dimensional half_float_16 array.
-    - float32_array: one dimensional float32 array.
-    - float64_array: one dimensional float64 array.
+  - array: multidimensional array which every sub-array can have different sizes but all have same type.
+  - bool_array: one dimensional int16 array.
+  - int8_array: one dimensional int8 array.
+  - int16_array: one dimensional int16 array.
+  - int32_array: one dimensional int32 array.
+  - int64_array: one dimensional int64 array.
+  - float16_array: one dimensional half_float_16 array.
+  - float32_array: one dimensional float32 array.
+  - float64_array: one dimensional float64 array.
 - tensor: a multidimensional dense array of fixed-size values such as a NumPy ndarray.
 - sparse tensor: a multidimensional array whose elements are almost all zeros.
 - arrow record batch: an arrow [record batch](https://arrow.apache.org/docs/cpp/tables.html#record-batches) object.
@@ -197,9 +198,9 @@ differently.
   of `type_id`. Schema evolution related meta will be ignored.
 - If schema evolution mode is enabled globally when creating fury, and current class is configured to use schema
   consistent mode like `struct` vs `table` in flatbuffers:
-    - Type meta will be add to `captured_type_defs`: `captured_type_defs[type def stub] = map size` ahead when
+  - Type meta will be add to `captured_type_defs`: `captured_type_defs[type def stub] = map size` ahead when
       registering type.
-    - Get index of the meta in `captured_type_defs`, write that index as `| unsigned varint: index |`.
+  - Get index of the meta in `captured_type_defs`, write that index as `| unsigned varint: index |`.
 
 ### Schema evolution
 
@@ -207,21 +208,24 @@ If schema evolution mode is enabled globally when creating fury, and enabled for
 using one of the following mode. Which mode to use is configured when creating fury.
 
 - Normal mode(meta share not enabled):
-    - If type meta hasn't been written before, add `type def`
+  - If type meta hasn't been written before, add `type def`
       to `captured_type_defs`: `captured_type_defs[type def] = map size`.
-    - Get index of the meta in `captured_type_defs`, write that index as `| unsigned varint: index |`.
-    - After finished the serialization of the object graph, fury will start to write `captured_type_defs`:
-        - Firstly, set current to `meta start offset` of fury header
-        - Then write `captured_type_defs` one by one:
-          ```python
-          buffer.write_var_uint32(len(writting_type_defs) - len(schema_consistent_type_def_stubs))
-          for type_meta in writting_type_defs:
-              if not type_meta.is_stub():
-                  type_meta.write_type_def(buffer)
-          writing_type_defs = copy(schema_consistent_type_def_stubs)
-          ```
+  - Get index of the meta in `captured_type_defs`, write that index as `| unsigned varint: index |`.
+  - After finished the serialization of the object graph, fury will start to write `captured_type_defs`:
+    - Firstly, set current to `meta start offset` of fury header
+    - Then write `captured_type_defs` one by one:
+
+      ```python
+      buffer.write_var_uint32(len(writting_type_defs) - len(schema_consistent_type_def_stubs))
+      for type_meta in writting_type_defs:
+          if not type_meta.is_stub():
+              type_meta.write_type_def(buffer)
+      writing_type_defs = copy(schema_consistent_type_def_stubs)
+      ```
+
 - Meta share mode: the writing steps are same as the normal mode, but `captured_type_defs` will be shared across
   multiple serializations of different objects. For example, suppose we have a batch to serialize:
+
     ```python
     captured_type_defs = {}
     stream = ...
@@ -234,16 +238,20 @@ using one of the following mode. Which mode to use is configured when creating f
     ```
 
 - Streaming mode(streaming mode doesn't support meta share):
-    - If type meta hasn't been written before, the data will be written as:
+  - If type meta hasn't been written before, the data will be written as:
+
       ```
       | unsigned varint: 0b11111111 | type def |
       ```
-    - If type meta has been written before, the data will be written as:
+
+  - If type meta has been written before, the data will be written as:
+
       ```
       | unsigned varint: written index << 1 |
       ```
+
       `written index` is the id in `captured_type_defs`.
-    - With this mode, `meta start offset` can be omitted.
+  - With this mode, `meta start offset` can be omitted.
 
 > The normal mode and meta share mode will forbid streaming writing since it needs to look back for update the start
 > offset after the whole object graph writing and meta collecting is finished. Only in this way we can ensure
@@ -281,33 +289,33 @@ Meta header is a 64 bits number value encoded in little endian order.
 ```
 
 - num fields: encode `num fields` as unsigned varint.
-    - If the current type is schema consistent, then num_fields will be `0` to flag it.
-    - If the current type isn't schema consistent, then num_fields will be the number of compatible fields. For example,
+  - If the current type is schema consistent, then num_fields will be `0` to flag it.
+  - If the current type isn't schema consistent, then num_fields will be the number of compatible fields. For example,
       users can use tag id to mark some fields as compatible fields in schema consistent context. In such cases, schema
       consistent fields will be serialized first, then compatible fields will be serialized next. At deserialization,
       Fury will use fields info of those fields which aren't annotated by tag id for deserializing schema consistent
       fields, then use fields info in meta for deserializing compatible fields.
 - type id: the registered id for the current type, which will be written as an unsigned varint.
 - field info:
-    - header(8
+  - header(8
       bits): `3 bits size + 2 bits field name encoding + polymorphism flag + nullability flag + ref tracking flag`.
       Users can use annotation to provide those info.
-        - 2 bits field name encoding:
-            - encoding: `UTF8/ALL_TO_LOWER_SPECIAL/LOWER_UPPER_DIGIT_SPECIAL/TAG_ID`
-            - If tag id is used, i.e. field name is written by an unsigned varint tag id. 2 bits encoding will be `11`.
-        - size of field name:
-            - The `3 bits size: 0~7`  will be used to indicate length `1~7`, the value `7` indicates to read more bytes,
+    - 2 bits field name encoding:
+      - encoding: `UTF8/ALL_TO_LOWER_SPECIAL/LOWER_UPPER_DIGIT_SPECIAL/TAG_ID`
+      - If tag id is used, i.e. field name is written by an unsigned varint tag id. 2 bits encoding will be `11`.
+    - size of field name:
+      - The `3 bits size: 0~7`  will be used to indicate length `1~7`, the value `7` indicates to read more bytes,
               the encoding will encode `size - 7` as a varint next.
-            - If encoding is `TAG_ID`, then num_bytes of field name will be used to store tag id.
-        - ref tracking: when set to 1, ref tracking will be enabled for this field.
-        - nullability: when set to 1, this field can be null.
-        - polymorphism: when set to 1, the actual type of field will be the declared field type even the type if
+      - If encoding is `TAG_ID`, then num_bytes of field name will be used to store tag id.
+    - ref tracking: when set to 1, ref tracking will be enabled for this field.
+    - nullability: when set to 1, this field can be null.
+    - polymorphism: when set to 1, the actual type of field will be the declared field type even the type if
           not `final`.
-    - field name: If tag id is set, tag id will be used instead. Otherwise meta string encoding `[length]` and data will
+  - field name: If tag id is set, tag id will be used instead. Otherwise meta string encoding `[length]` and data will
       be written instead.
-    - type id:
-        - For registered type-consistent classes, it will be the registered type id.
-        - Otherwise it will be encoded as `OBJECT_ID` if it isn't `final` and `FINAL_OBJECT_ID` if it's `final`. The
+  - type id:
+    - For registered type-consistent classes, it will be the registered type id.
+    - Otherwise it will be encoded as `OBJECT_ID` if it isn't `final` and `FINAL_OBJECT_ID` if it's `final`. The
           meta for such types is written separately instead of inlining here is to reduce meta space cost if object of
           this type is serialized in current object graph multiple times, and the field value may be null too.
 
@@ -401,10 +409,10 @@ Notes:
 
 - size: 1~9 byte
 - Fury SLI(Small long as int) Encoding:
-    - If long is in `[0, 2147483647]`, encode as 4 bytes int: `| little-endian: ((int) value) << 1 |`
-    - Otherwise write as 9 bytes: `| 0b1 | little-endian 8 bytes long |`
+  - If long is in `[0, 2147483647]`, encode as 4 bytes int: `| little-endian: ((int) value) << 1 |`
+  - Otherwise write as 9 bytes: `| 0b1 | little-endian 8 bytes long |`
 - Fury PVL(Progressive Variable-length Long) Encoding:
-    - positive long format: first bit in every byte indicates whether to have the next byte. If first bit is set
+  - positive long format: first bit in every byte indicates whether to have the next byte. If first bit is set
       i.e. `b & 0x80 == 0x80`, then the next byte should be read until the first bit is unset.
 
 #### signed int64
@@ -416,10 +424,10 @@ Notes:
 
 - size: 1~9 byte
 - Fury SLI(Small long as int) Encoding:
-    - If long is in `[-1073741824, 1073741823]`, encode as 4 bytes int: `| little-endian: ((int) value) << 1 |`
-    - Otherwise write as 9 bytes: `| 0b1 | little-endian 8 bytes long |`
+  - If long is in `[-1073741824, 1073741823]`, encode as 4 bytes int: `| little-endian: ((int) value) << 1 |`
+  - Otherwise write as 9 bytes: `| 0b1 | little-endian 8 bytes long |`
 - Fury PVL(Progressive Variable-length Long) Encoding:
-    - First convert the number into positive unsigned long by `(v << 1) ^ (v >> 63)` ZigZag algorithm to reduce cost of
+  - First convert the number into positive unsigned long by `(v << 1) ^ (v >> 63)` ZigZag algorithm to reduce cost of
       small negative numbers, then encoding it as an unsigned long.
 
 #### float32
diff --git a/integration_tests/README.md b/integration_tests/README.md
index 60f1ffd59f..ca3571f9ed 100644
--- a/integration_tests/README.md
+++ b/integration_tests/README.md
@@ -1,4 +1,5 @@
-Integration tests for fury:
+# Integration tests for fury:
+
 - [jdk_compatibility_tests](jdk_compatibility_tests): test fury compatibility across multiple jdk versions.
 - [latest_jdk_tests](latest_jdk_tests): test latest jdk.
 - [graalvm_tests](graalvm_tests): test graalvm native image support.
diff --git a/integration_tests/graalvm_tests/README.md b/integration_tests/graalvm_tests/README.md
index 620a408d3e..1cecb4e483 100644
--- a/integration_tests/graalvm_tests/README.md
+++ b/integration_tests/graalvm_tests/README.md
@@ -1,14 +1,18 @@
 # Graalvm native image Tests
+
 Examples and tests for Fury serialization in graalvm native image
 
 ## Test
+
 ```bash
 mvn -DskipTests=true -Pnative package
 ```
 
 ## Benchmark
+
 ```bash
 BENCHMARK_REPEAT=400000 mvn -Pnative -Dagent=true -DskipTests -DskipNativeBuild=true package exec:exec@java-agent
 BENCHMARK_REPEAT=400000 mvn -DskipTests=true -Pnative -Dagent=true package
 ```
-`-Dagent=true` is needed by JDK serialization only to build reflection config, it's not needed for fury serialization.
\ No newline at end of file
+
+`-Dagent=true` is needed by JDK serialization only to build reflection config, it's not needed for fury serialization.
diff --git a/java/benchmark/README.md b/java/benchmark/README.md
index 4d152a3143..64ab798f4c 100644
--- a/java/benchmark/README.md
+++ b/java/benchmark/README.md
@@ -1,6 +1,7 @@
 # Fury Java Benchmark
 
 Fury Java Benchmark contains benchmarks for:
+
 - Fury
 - JDK
 - Hession
@@ -14,7 +15,8 @@ Fury Java Benchmark contains benchmarks for:
 > Part of benchmark data is based on [Kryo benchmark](https://github.com/EsotericSoftware/kryo/tree/master/benchmarks).
 > Kryo benchmark suite is based on [Kryo benchmark](https://github.com/EsotericSoftware/kryo/tree/master/benchmarks).
 
-# How to run
+## How to run
+
 This benchmark use [jmh](https://github.com/openjdk/jmh) as benchmark tool. [jmh](https://github.com/openjdk/jmh) is
 licensed under GPL V2 with CLASSPATH exception, the usage can't be included in apache source/binary release unless
 as an optional feature. So Fury make it as an optional dependency and you must enable `jmh` profile to activate it.
@@ -33,13 +35,15 @@ java -jar target/benchmarks.jar "org.apache.fury.*\.deserialize$" -f 1 -wi 1 -i
 ```
 
 Generate Protobuf/Flatbuffers code manually:
+
 ```bash
 flatc  -o src/main/java -j  src/main/java/org/apache/fury/integration_tests/state/bench.fbs
 protoc -I=src/main/java/org/apache/fury/integration_tests/state --java_out=src/main/java/ bench.proto
 ```
+
 Protobuf code can be generated by maven plugin automatically. Flatbuffers generated code is short, so we added generated files to repo directly.
 
-# Maven run
+## Maven run
 
 ```bash
 cd .. && mvn -T10 install -DskipTests -Dcheckstyle.skip -Dlicense.skip -Dmaven.javadoc.skip
@@ -60,7 +64,7 @@ See `org.openjdk.jmh.runner.options.CommandLineOptions` for more information abo
 
 Save benchmark data to specified dir, then run `tool.py` to plot graphs.
 
-# Plotting
+## Plotting
 
 Fury uses pandas to process the jmh data, and uses matplotlib for plotting.
 
@@ -69,7 +73,7 @@ pip install pandas matplotlib
 python analyze.py
 ```
 
-# Debug
+## Debug
 
 Using `async-profiler` to generate flame graph.
 
@@ -79,17 +83,17 @@ nohup java -jar target/benchmarks.jar 'org.apache.fury.*Fury.*deserialize*' -f 1
 profiler.sh  -d 30 -f $pic `jps | grep ForkedMain | awk '{print $1}'`
 ```
 
-# JIT optimization
+## JIT optimization
 
 1. Use `-XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining` to inspect JIT:
    `java -XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining -jar target/benchmarks.jar org.apache.fury.*Fury.* UserTypeBenchmark.serialize -f 0 -wi 1 -i 1 -t 1 -w 1s -r 35s -rf csv > compile.log`
 2. Determine what the flags are set to on current platform:
-   * Use `java ${other_options} -XX:+PrintFlagsFinal -version`, should include all other options on the command line because some options affect others, particularly when setting GC-related flags.
-   * `jcmd $pid VM.flags -all` -XX:FreqInlineSize= flag specifies the maximum number of bytecode instructions to inline for a method. The default value depends on the platform – for 64-bit Linux, it's 325.
+   - Use `java ${other_options} -XX:+PrintFlagsFinal -version`, should include all other options on the command line because some options affect others, particularly when setting GC-related flags.
+   - `jcmd $pid VM.flags -all` -XX:FreqInlineSize= flag specifies the maximum number of bytecode instructions to inline for a method. The default value depends on the platform – for 64-bit Linux, it's 325.
 3. `hot method too big` need to be optimized.
 4. See:
-   * https://wiki.openjdk.java.net/display/HotSpot/Server+Compiler+Inlining+Messages
-   * https://techblug.wordpress.com/2013/08/19/java-jit-compiler-inlining/
+   - https://wiki.openjdk.java.net/display/HotSpot/Server+Compiler+Inlining+Messages
+   - https://techblug.wordpress.com/2013/08/19/java-jit-compiler-inlining/
 5. escape analysis
 6. -server -XX:+TieredCompilation: In Java 8, when the server compiler is enabled, tiered compilation
    is also enabled by default. 64-bit java8 use server compiler by default(use java -version to check).
diff --git a/python/README.md b/python/README.md
index 836b8d30b4..73704ab108 100644
--- a/python/README.md
+++ b/python/README.md
@@ -40,9 +40,9 @@ cd python
 python setup.py develop
 ```
 
-* Use `cython --cplus -a  pyfury/_serialization.pyx` to produce an annotated HTML file of the source code. Then you can
+- Use `cython --cplus -a  pyfury/_serialization.pyx` to produce an annotated HTML file of the source code. Then you can
   analyze interaction between Python objects and Python's C API.
-* Read more: https://cython.readthedocs.io/en/latest/src/userguide/debugging.html
+- Read more: <https://cython.readthedocs.io/en/latest/src/userguide/debugging.html>
 
 ```bash
 FURY_DEBUG=true python setup.py build_ext --inplace
diff --git a/rust/README.md b/rust/README.md
index 2bbfaee596..058b5bc1a8 100644
--- a/rust/README.md
+++ b/rust/README.md
@@ -1,6 +1,7 @@
 # Apache Fury™ Rust
 
-Fury is a blazingly fast multi-language serialization framework powered by just-in-time compilation and zero-copy.
+Fury is a blazingly fast multi-language serialization framework powered by
+just-in-time compilation and zero-copy.
 
 Fury Rust can be implemented by steps:
 
diff --git a/scala/README.md b/scala/README.md
index 3691639b2e..c7d729bee4 100644
--- a/scala/README.md
+++ b/scala/README.md
@@ -1,6 +1,7 @@
 # Apache Fury™ Scala
 
 Fury supports all scala object serialization:
+
 - `case` class serialization supported
 - `pojo/bean` class serialization supported
 - `object` singleton serialization supported