diff --git a/Cargo.toml b/Cargo.toml
index 22a207f..5c39823 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ply-rs-bw"
-version = "0.1.4"
+version = "1.0.0"
 authors = ["Felice Serena <felice@serena-mueller.ch>","Bourumir Wyngs<use@github_to_contact"]
 repository = "https://github.com/bourumir-wyngs/ply-rs"
 homepage = "https://github.com/bourumir-wyngs/ply-rs"
@@ -39,5 +39,8 @@ name = "read_ply_header_only"
 [[example]]
 name = "read_ply_to_structs"
 
+[[example]]
+name = "read_diverse_field_types"
+
 [[example]]
 name = "write_empty_ply"
diff --git a/README.md b/README.md
index dcf309e..c531695 100644
--- a/README.md
+++ b/README.md
@@ -7,9 +7,15 @@
 [![docs.rs](https://docs.rs/ply-rs-bw/badge.svg)](https://docs.rs/ply-rs-bw)
 [![Dependency Vulnerabilities](https://img.shields.io/endpoint?url=https%3A%2F%2Fapi-hooks.soos.io%2Fapi%2Fshieldsio-badges%3FbadgeType%3DDependencyVulnerabilities%26pid%3Dkyhfgom8c%26)](https://app.soos.io)
 
-This is a forked version of [ply-rs](https://github.com/Fluci/ply-rs) project that fixes the usage of 
-linked-hash-map to address [CVE-2020-25573](https://nvd.nist.gov/vuln/detail/CVE-2020-25573). We may make other small maintenance fixes. The crate renamed all over to ply-rs-bw
-and small glitches were fixed to make it Rust edition 2021 - compliant.
+This is a forked version of the [ply-rs](https://github.com/Fluci/ply-rs) project that addresses the use of
+`linked-hash-map` to resolve [CVE-2020-25573](https://nvd.nist.gov/vuln/detail/CVE-2020-25573). Other small
+maintenance fixes may also be included.
+
+The crate has been renamed to `ply-rs-bw`, and minor issues were resolved to ensure compatibility with Rust 2021
+edition. Additionally, an example has been added to demonstrate how to read PLY files with diverse field types
+(e.g., `f32` vs `f64`, `u32` vs `i32`, etc.). Semantic versioning is now adopted for consistent version management.
+
+***
 
 Ply-rs is a small library built to read and write the PLY file format (also Polygon File Format, Standford Triangle Format). The library supports all three subformats: ascii, big endian, and little endian.
 
@@ -26,7 +32,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-ply-rs-bw = "0.1.3"
+ply-rs-bw = "1.0.0"
 ```
 
 Add to your root:
diff --git a/example_plys/diverse_field_formats/doubles_ints.ply b/example_plys/diverse_field_formats/doubles_ints.ply
new file mode 100644
index 0000000..1915ff4
Binary files /dev/null and b/example_plys/diverse_field_formats/doubles_ints.ply differ
diff --git a/example_plys/diverse_field_formats/doubles_shorts.ply b/example_plys/diverse_field_formats/doubles_shorts.ply
new file mode 100644
index 0000000..c07a272
Binary files /dev/null and b/example_plys/diverse_field_formats/doubles_shorts.ply differ
diff --git a/example_plys/diverse_field_formats/floats_ints.ply b/example_plys/diverse_field_formats/floats_ints.ply
new file mode 100644
index 0000000..643173a
Binary files /dev/null and b/example_plys/diverse_field_formats/floats_ints.ply differ
diff --git a/example_plys/diverse_field_formats/floats_shorts.ply b/example_plys/diverse_field_formats/floats_shorts.ply
new file mode 100644
index 0000000..4cf7c09
Binary files /dev/null and b/example_plys/diverse_field_formats/floats_shorts.ply differ
diff --git a/examples/read_diverse_field_types.rs b/examples/read_diverse_field_types.rs
new file mode 100644
index 0000000..df85d84
--- /dev/null
+++ b/examples/read_diverse_field_types.rs
@@ -0,0 +1,122 @@
+
+use ply_rs_bw::parser::Parser;
+use ply_rs_bw::ply::{DefaultElement, Property};
+use std::fs::File;
+use std::io::BufReader;
+
+/// Loads a mesh from a file, returning a list of vertices (x, y, z represented as `f32`)
+/// and triangle indices (indices represented as `u32`).
+///
+/// This example focuses on real-world scenarios where fields may be represented using
+/// different types (e.g., `f32` vs `f64`, `u32` vs `i32`, etc.). To read PLY data
+/// from various sources, the reader must adapt to the types used in the input.
+pub fn read_mesh(ply_file_path: &str) -> (Vec<[f32; 3]>, Vec<[u32; 3]>) {
+    // Open the file
+    let file =
+        File::open(ply_file_path).expect(&format!("Could not open PLY file: {}", ply_file_path));
+    let mut reader = BufReader::new(file);
+
+    // Create a PLY parser and parse the header
+    let parser = Parser::<DefaultElement>::new();
+    let ply = parser
+        .read_ply(&mut reader)
+        .expect(&format!("Could not parse PLY file: {}", ply_file_path));
+
+    // Extract vertices and faces from the PLY file
+    let mut vertices = Vec::new();
+    let mut indices = Vec::new();
+
+    // PLY may have internally different types.
+    if let Some(vertices_elem) = ply.payload.get("vertex") {
+        for vertex in vertices_elem {
+            let x = match vertex.get("x").unwrap() {
+                Property::Float(val) => *val,
+                Property::Double(val) => *val as f32,
+                _ => panic!("Unexpected type for vertex x"),
+            };
+            let y = match vertex.get("y").unwrap() {
+                Property::Float(val) => *val,
+                Property::Double(val) => *val as f32,
+                _ => panic!("Unexpected type for vertex y"),
+            };
+            let z = match vertex.get("z").unwrap() {
+                Property::Float(val) => *val,
+                Property::Double(val) => *val as f32,
+                _ => panic!("Unexpected type for vertex z"),
+            };
+
+            vertices.push([x, y, z].into()); // Push vertex to the vertices list
+        }
+    }
+
+    // Extract faces (indices)
+    fn extract_indices<T>(indices_list: &[T], i: usize) -> [u32; 3]
+    where
+        T: TryInto<u32> + Copy,
+        <T as TryInto<u32>>::Error: std::fmt::Debug,
+    {
+        if indices_list.len() < 3 {
+            panic!("Insufficient indices for a triangle in face {}", i);
+        }
+        const X: &'static str = "Failed to convert triangle index to u32";
+        [
+            indices_list[0].try_into().expect(X),
+            indices_list[1].try_into().expect(X),
+            indices_list[2].try_into().expect(X),
+        ]
+    }
+
+    if let Some(faces_elem) = ply.payload.get("face") {
+        for (i, face) in faces_elem.iter().enumerate() {
+            match face.get("vertex_indices") {
+                Some(Property::ListUInt(indices_list)) => {
+                    indices.push(extract_indices(indices_list, i).into());
+                }
+                Some(Property::ListInt(indices_list)) => {
+                    indices.push(extract_indices(indices_list, i).into());
+                }
+                Some(Property::ListUShort(indices_list)) => {
+                    indices.push(extract_indices(indices_list, i).into());
+                }
+                Some(Property::ListShort(indices_list)) => {
+                    indices.push(extract_indices(indices_list, i).into());
+                }
+                Some(property) => {
+                    panic!("Unexpected property type for face {}: {:?}", i, property);
+                }
+                None => {
+                    panic!("Missing 'vertex_indices' for face {}", i);
+                }
+            }
+        }
+    } else {
+        panic!("No 'face' element in payload");
+    }
+
+    (vertices, indices)
+}
+
+/// Helper function to print the results. Examples used only contain a single triangle.
+/// Python script used for generating test data can be found in the folder 'scripts'
+fn print_ply_data(data: (Vec<[f32; 3]>, Vec<[u32; 3]>)) {
+    let (vertices, indices) = data;
+
+    println!("Vertices:");
+    for (i, vertex) in vertices.iter().enumerate() {
+        println!("  {}: [{:.3}, {:.3}, {:.3}]", i, vertex[0], vertex[1], vertex[2]);
+    }
+
+    println!("Indices:");
+    for (i, index) in indices.iter().enumerate() {
+        println!("  {}: [{}, {}, {}]", i, index[0], index[1], index[2]);
+    }
+}
+
+
+fn main() {
+    // The output from four lines below must be identical.
+    print_ply_data(read_mesh("example_plys/diverse_field_formats/doubles_ints.ply"));
+    print_ply_data(read_mesh("example_plys/diverse_field_formats/doubles_shorts.ply"));
+    print_ply_data(read_mesh("example_plys/diverse_field_formats/floats_ints.ply"));
+    print_ply_data(read_mesh("example_plys/diverse_field_formats/floats_shorts.ply"));
+}
\ No newline at end of file
diff --git a/scripts/generate_diverse_field_types.py b/scripts/generate_diverse_field_types.py
new file mode 100644
index 0000000..27a358a
--- /dev/null
+++ b/scripts/generate_diverse_field_types.py
@@ -0,0 +1,57 @@
+import struct
+
+
+def write_ply(filename, vertex_format, index_format, vertices, face):
+    """
+    Writes a PLY file with the given vertex and face formats.
+
+    Args:
+        filename (str): Name of the output file.
+        vertex_format (str): Format string for vertex coordinates.
+        index_format (str): Format string for face indices.
+        vertices (list): List of vertices (tuples of coordinates).
+        face (list): Face data (count followed by vertex indices).
+    """
+    # Map formats to PLY property declarations
+    vertex_properties = {
+        '<fff': 'property float x\nproperty float y\nproperty float z\n',
+        '<ddd': 'property double x\nproperty double y\nproperty double z\n',
+    }
+    index_properties = {
+        '<Biii': 'property list uchar int vertex_indices\n',
+        '<Bhhh': 'property list uchar short vertex_indices\n',
+    }
+
+    # Create the PLY header
+    header = f"""ply
+format binary_little_endian 1.0
+element vertex {len(vertices)}
+{vertex_properties[vertex_format]}element face 1
+{index_properties[index_format]}end_header
+"""
+
+    with open(filename, 'wb') as file:
+        # Write header
+        file.write(header.encode('ascii'))
+        # Write vertex data
+        for vertex in vertices:
+            file.write(struct.pack(vertex_format, *vertex))
+        # Write face data
+        file.write(struct.pack('<B', face[0]))  # Face count as uchar
+        face_indices_format = index_format[2:]  # Extract the index part of the format
+        file.write(struct.pack(face_indices_format, *face[1:]))
+
+
+# Define vertex data and face data
+vertices = [
+    (1.0, 2.0, 3.0),  # Vertex 1
+    (4.0, 5.0, 6.0),  # Vertex 2
+    (7.0, 8.0, 9.0),  # Vertex 3
+]
+face = [3, 0, 1, 2]  # A single triangular face
+
+# Generate files with various combinations
+write_ply('../example_plys/diverse_field_formats/floats_ints.ply', '<fff', '<Biii', vertices, face)  # Float vertices, Int indices
+write_ply('../example_plys/diverse_field_formats/floats_shorts.ply', '<fff', '<Bhhh', vertices, face)  # Float vertices, Short indices
+write_ply('../example_plys/diverse_field_formats/doubles_ints.ply', '<ddd', '<Biii', vertices, face)  # Double vertices, Int indices
+write_ply('../example_plys/diverse_field_formats/doubles_shorts.ply', '<ddd', '<Bhhh', vertices, face)  # Double vertices, Short indices