diff --git a/docs/CHANGES.TXT b/docs/CHANGES.TXT
index 5042253ba..8b3576635 100644
--- a/docs/CHANGES.TXT
+++ b/docs/CHANGES.TXT
@@ -1,5 +1,6 @@
 1.0 (to be released)
 -----------------
+- New: Add Encoder Module to Rust
 - Fix: Elementary stream regressions
 - Fix: Segmentation faults on XDS files
 - Fix: Clippy Errors Based on Rust 1.88
diff --git a/src/lib_ccx/ccx_encoders_common.c b/src/lib_ccx/ccx_encoders_common.c
index c2540dd10..2c77e3f90 100644
--- a/src/lib_ccx/ccx_encoders_common.c
+++ b/src/lib_ccx/ccx_encoders_common.c
@@ -19,6 +19,10 @@ int fsync(int fd)
 }
 #endif
 
+#ifndef DISABLE_RUST
+int ccxr_get_str_basic(unsigned char *out_buffer, unsigned char *in_buffer, int trim_subs,
+		       enum ccx_encoding_type in_enc, enum ccx_encoding_type out_enc, int max_len);
+#endif
 // These are the default settings for plain transcripts. No times, no CC or caption mode, and no XDS.
 ccx_encoders_transcript_format ccx_encoders_default_transcript_settings =
     {
@@ -293,6 +297,9 @@ int change_ascii_encoding(unsigned char *dest, unsigned char *src, int len, enum
 int get_str_basic(unsigned char *out_buffer, unsigned char *in_buffer, int trim_subs,
 		  enum ccx_encoding_type in_enc, enum ccx_encoding_type out_enc, int max_len)
 {
+#ifndef DISABLE_RUST
+	return ccxr_get_str_basic(out_buffer, in_buffer, trim_subs, in_enc, out_enc, max_len);
+#else
 	int last_non_blank = -1;
 	int first_non_blank = -1;
 	int len = 0;
@@ -305,7 +312,6 @@ int get_str_basic(unsigned char *out_buffer, unsigned char *in_buffer, int trim_
 		*out_buffer = 0;
 		return 0;
 	}
-
 	// change encoding only when required
 	switch (in_enc)
 	{
@@ -331,6 +337,7 @@ int get_str_basic(unsigned char *out_buffer, unsigned char *in_buffer, int trim_
 		return (unsigned)len; // Return length
 
 	return 0; // Return length
+#endif
 }
 
 int write_subtitle_file_footer(struct encoder_ctx *ctx, struct ccx_s_write *out)
@@ -631,8 +638,8 @@ int write_cc_buffer_as_simplexml(struct eia608_screen *data, struct encoder_ctx
 		if (data->row_used[i])
 		{
 			write_cc_line_as_simplexml(data, context, i);
+			wrote_something = 1;
 		}
-		wrote_something = 1;
 	}
 	return wrote_something;
 }
diff --git a/src/lib_ccx/ccx_encoders_spupng.c b/src/lib_ccx/ccx_encoders_spupng.c
index 815c521ed..17da7803b 100644
--- a/src/lib_ccx/ccx_encoders_spupng.c
+++ b/src/lib_ccx/ccx_encoders_spupng.c
@@ -29,18 +29,6 @@ FT_Face face_regular = NULL;
 FT_Face face_italics = NULL;
 FT_Face face = NULL;
 
-struct spupng_t
-{
-	FILE *fpxml;
-	FILE *fppng;
-	char *dirname;
-	char *pngfile;
-	char *relative_path_png;
-	int fileIndex;
-	int xOffset;
-	int yOffset;
-};
-
 #define CCPL (ccfont2_width / CCW * ccfont2_height / CCH)
 
 static int initialized = 0;
diff --git a/src/lib_ccx/ccx_encoders_structs.h b/src/lib_ccx/ccx_encoders_structs.h
index 6c4d3cdb6..83adc509c 100644
--- a/src/lib_ccx/ccx_encoders_structs.h
+++ b/src/lib_ccx/ccx_encoders_structs.h
@@ -29,4 +29,16 @@ struct ccx_s_write
 
 };
 
+struct spupng_t
+{
+	FILE *fpxml;
+	FILE *fppng;
+	char *dirname;
+	char *pngfile;
+	char *relative_path_png;
+	int fileIndex;
+	int xOffset;
+	int yOffset;
+};
+
 #endif
diff --git a/src/rust/build.rs b/src/rust/build.rs
index 482694e86..a2005dd65 100644
--- a/src/rust/build.rs
+++ b/src/rust/build.rs
@@ -12,6 +12,9 @@ fn main() {
         "writercwtdata",
         "version",
         "set_binary_mode",
+        "net_send_header", // shall be removed after NET
+        "write_spumux_footer",
+        "write_spumux_header",
     ]);
 
     #[cfg(feature = "hardsubx_ocr")]
@@ -39,6 +42,7 @@ fn main() {
         "ccx_encoding_type",
         "ccx_decoder_608_settings",
         "ccx_decoder_608_report",
+        "eia608_screen",
         "uint8_t",
         "word_list",
     ]);
diff --git a/src/rust/lib_ccxr/src/encoder/mod.rs b/src/rust/lib_ccxr/src/encoder/mod.rs
new file mode 100644
index 000000000..8425cfb5a
--- /dev/null
+++ b/src/rust/lib_ccxr/src/encoder/mod.rs
@@ -0,0 +1,4 @@
+pub mod txt_helpers;
+/* Note
+This is a part of the encoder library, which is made in pure rust; hence it's kept in `lib_ccxr` instead of `src`.
+ */
diff --git a/src/rust/lib_ccxr/src/encoder/txt_helpers.rs b/src/rust/lib_ccxr/src/encoder/txt_helpers.rs
new file mode 100644
index 000000000..a1986b9ee
--- /dev/null
+++ b/src/rust/lib_ccxr/src/encoder/txt_helpers.rs
@@ -0,0 +1,427 @@
+use crate::info;
+use crate::util::encoding::*;
+use std::cmp;
+use std::convert::TryFrom;
+
+pub enum EncoderError {
+    Retry = -100,           // CCX_EAGAIN
+    EOF = -101,             // CCX_EOF
+    InvalidArgument = -102, // CCX_EINVAL
+    Unsupported = -103,     // CCX_ENOSUPP
+    OutOfMemory = -104,     // CCX_ENOMEM
+}
+
+fn find_limit_characters(
+    line: &[u8],
+    first_non_blank: &mut i32,
+    last_non_blank: &mut i32,
+    max_len: usize,
+) {
+    *first_non_blank = -1;
+    *last_non_blank = -1;
+
+    let limit = cmp::min(line.len(), max_len);
+
+    for (i, &c) in line.iter().take(limit).enumerate() {
+        if c == b'\0' || c == b'\n' || c == b'\r' {
+            break;
+        }
+        if c != b' ' && c != 0x89 {
+            if *first_non_blank < 0 {
+                *first_non_blank = i as i32;
+            }
+            *last_non_blank = i as i32;
+        }
+    }
+}
+
+fn change_utf8_encoding(dest: &mut [u8], src: &[u8], len: i32, out_enc: Encoding) -> i32 {
+    let mut dest_idx = 0;
+    let mut src_idx = 0;
+    let max = usize::min(src.len(), len as usize);
+
+    while src_idx < max {
+        let c = src[src_idx];
+        let c_len: usize;
+
+        if c < 0x80 {
+            c_len = 1;
+        } else if (c & 0x20) == 0 {
+            c_len = 2;
+        } else if (c & 0x10) == 0 {
+            c_len = 3;
+        } else if (c & 0x08) == 0 {
+            c_len = 4;
+        } else if (c & 0x04) == 0 {
+            c_len = 5;
+        } else {
+            c_len = 1;
+        }
+
+        match out_enc {
+            Encoding::UTF8 => {
+                if max <= dest.len() {
+                    dest[..max].copy_from_slice(&src[..max]);
+                    return max as i32;
+                } else {
+                    return EncoderError::Unsupported as i32;
+                }
+            }
+            Encoding::Latin1 => {
+                let cp = if c_len == 1 {
+                    src[src_idx] as u32
+                } else if c_len == 2 && src_idx + 1 < max && (src[src_idx + 1] & 0x40) == 0 {
+                    (((src[src_idx] & 0x1F) as u32) << 6) | ((src[src_idx + 1] & 0x3F) as u32)
+                } else if c_len == 3
+                    && src_idx + 2 < max
+                    && (src[src_idx + 1] & 0x40) == 0
+                    && (src[src_idx + 2] & 0x40) == 0
+                {
+                    (((src[src_idx] & 0x0F) as u32) << 12)
+                        | (((src[src_idx + 1] & 0x3F) as u32) << 6)
+                        | ((src[src_idx + 2] & 0x3F) as u32)
+                } else if c_len == 4
+                    && src_idx + 3 < max
+                    && (src[src_idx + 1] & 0x40) == 0
+                    && (src[src_idx + 2] & 0x40) == 0
+                    && (src[src_idx + 3] & 0x40) == 0
+                {
+                    (((src[src_idx] & 0x07) as u32) << 18)
+                        | (((src[src_idx + 1] & 0x3F) as u32) << 12)
+                        | (((src[src_idx + 2] & 0x3F) as u32) << 6)
+                        | ((src[src_idx + 3] & 0x3F) as u32)
+                } else if c_len == 5
+                    && src_idx + 4 < max
+                    && (src[src_idx + 1] & 0x40) == 0
+                    && (src[src_idx + 2] & 0x40) == 0
+                    && (src[src_idx + 3] & 0x40) == 0
+                    && (src[src_idx + 4] & 0x40) == 0
+                {
+                    (((src[src_idx] & 0x03) as u32) << 24u32)
+                        | (((src[src_idx + 1] & 0x3F) as u32) << 18u32)
+                        | (((src[src_idx + 2] & 0x3F) as u32) << 12u32)
+                        | (((src[src_idx + 3] & 0x3F) as u32) << 6u32)
+                        | ((src[src_idx + 4] & 0x3F) as u32)
+                } else {
+                    0x3F
+                };
+
+                if c_len == 1 || cp == 0x3F {
+                    dest[dest_idx] = if c_len == 1 { src[src_idx] } else { b'?' };
+                } else {
+                    let mapped_cp = utf8_to_latin1_map(cp) as u16;
+                    dest[dest_idx] = if mapped_cp <= 255 {
+                        mapped_cp as u8
+                    } else {
+                        b'?'
+                    };
+                }
+                dest_idx += 1;
+            }
+            Encoding::UCS2 => {
+                return EncoderError::Unsupported as i32;
+            }
+            Encoding::Line21 => {
+                dest[dest_idx] = if c_len == 1 { src[src_idx] } else { b'?' };
+                dest_idx += 1;
+            }
+        }
+        src_idx += c_len;
+    }
+
+    if dest_idx < dest.len() {
+        dest[dest_idx] = 0;
+    }
+    dest_idx as i32
+}
+
+#[allow(unused_variables)]
+fn change_latin1_encoding(dest: &mut [u8], src: &[u8], len: i32, out_enc: Encoding) -> i32 {
+    EncoderError::Unsupported as i32
+}
+
+#[allow(unused_variables)]
+fn change_unicode_encoding(dest: &mut [u8], src: &[u8], len: i32, out_enc: Encoding) -> i32 {
+    EncoderError::Unsupported as i32
+}
+
+pub fn change_ascii_encoding(
+    dest: &mut Vec<u8>,
+    src: &[u8],
+    out_enc: Encoding,
+) -> Result<usize, i32> {
+    dest.clear();
+
+    for &c in src {
+        match out_enc {
+            Encoding::UTF8 => {
+                let utf8_char = line21_to_utf8(c);
+                let first_non_zero = (utf8_char.leading_zeros() / 8) as usize;
+                let bytes = utf8_char.to_be_bytes();
+                let byte_count = bytes.len() - first_non_zero;
+                if byte_count == 0 || byte_count > 4 {
+                    return Err(-1);
+                }
+                dest.extend_from_slice(&bytes[first_non_zero..(first_non_zero + byte_count)]);
+            }
+            Encoding::Latin1 => {
+                let latin1_char = line21_to_latin1(c);
+                dest.push(latin1_char);
+            }
+            Encoding::UCS2 => {
+                let ucs2_char = line21_to_ucs2(c);
+                dest.extend_from_slice(&ucs2_char.to_le_bytes());
+            }
+            Encoding::Line21 => {
+                dest.extend_from_slice(src);
+                return Ok(src.len());
+            }
+        }
+    }
+
+    dest.push(0);
+
+    Ok(dest.len() - 1)
+}
+
+fn utf8_to_latin1_map(character: u32) -> Latin1Char {
+    ucs2_to_latin1(char_to_ucs2(char::try_from(character).unwrap()))
+}
+
+pub fn get_str_basic(
+    out_buffer: &mut Vec<u8>,
+    in_buffer: &[u8],
+    trim_subs: bool,
+    in_enc: Encoding,
+    out_enc: Encoding,
+    max_len: i32,
+) -> i32 {
+    let mut last_non_blank: i32 = -1;
+    let mut first_non_blank: i32 = -1;
+    let len;
+
+    find_limit_characters(
+        in_buffer,
+        &mut first_non_blank,
+        &mut last_non_blank,
+        max_len as usize,
+    );
+
+    if first_non_blank == -1 {
+        out_buffer.clear();
+        out_buffer.push(0);
+        return 0;
+    }
+
+    let mut content_length = last_non_blank - first_non_blank + 1;
+
+    if !trim_subs {
+        first_non_blank = 0;
+        content_length = last_non_blank + 1;
+    }
+
+    if (first_non_blank + content_length) as usize > in_buffer.len() {
+        out_buffer.clear();
+        out_buffer.push(0);
+        return 0;
+    }
+
+    out_buffer.clear();
+
+    match in_enc {
+        Encoding::UTF8 => {
+            let mut temp_buffer = vec![0u8; (content_length * 4) as usize];
+            len = change_utf8_encoding(
+                &mut temp_buffer,
+                &in_buffer[first_non_blank as usize..],
+                content_length,
+                out_enc,
+            );
+            if len > 0 {
+                out_buffer.extend_from_slice(&temp_buffer[..len as usize]);
+            }
+        }
+        Encoding::Latin1 => {
+            let mut temp_buffer = vec![0u8; (content_length * 4) as usize];
+            len = change_latin1_encoding(
+                &mut temp_buffer,
+                &in_buffer[first_non_blank as usize..],
+                content_length,
+                out_enc,
+            );
+            if len > 0 {
+                out_buffer.extend_from_slice(&temp_buffer[..len as usize]);
+            }
+        }
+        Encoding::UCS2 => {
+            let mut temp_buffer = vec![0u8; (content_length * 4) as usize];
+            len = change_unicode_encoding(
+                &mut temp_buffer,
+                &in_buffer[first_non_blank as usize..],
+                content_length,
+                out_enc,
+            );
+            if len > 0 {
+                out_buffer.extend_from_slice(&temp_buffer[..len as usize]);
+            }
+        }
+        Encoding::Line21 => {
+            let input_slice =
+                &in_buffer[first_non_blank as usize..(first_non_blank + content_length) as usize];
+            len = change_ascii_encoding(out_buffer, input_slice, out_enc)
+                .unwrap_or(EncoderError::Retry as usize) as i32;
+        }
+    }
+
+    if len < 0 {
+        info!("WARNING: Could not encode in specified format\n");
+        out_buffer.clear();
+        out_buffer.push(0);
+        0
+    } else if len == EncoderError::Unsupported as i32 {
+        info!("WARNING: Encoding is not yet supported\n");
+        out_buffer.clear();
+        out_buffer.push(0);
+        return 0;
+    } else {
+        out_buffer.push(0);
+        return len;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_line_with_content() {
+        let line = b"  hello world  \n";
+        let mut first_non_blank = 0;
+        let mut last_non_blank = 0;
+
+        find_limit_characters(line, &mut first_non_blank, &mut last_non_blank, 15);
+
+        assert_eq!(first_non_blank, 2);
+        assert_eq!(last_non_blank, 12);
+    }
+
+    #[test]
+    fn test_line_with_special_chars() {
+        let line = b" \x89 abc \x89 def \r";
+        let mut first_non_blank = 0;
+        let mut last_non_blank = 0;
+
+        find_limit_characters(line, &mut first_non_blank, &mut last_non_blank, 20);
+
+        assert_eq!(first_non_blank, 3);
+    }
+    #[test]
+    fn test_utf8_to_utf8() {
+        let src = b"Hello, \xC3\xA9world!";
+        let mut dest = [0u8; 20];
+
+        let result = change_utf8_encoding(&mut dest, src, src.len() as i32, Encoding::UTF8);
+
+        assert_eq!(result, src.len() as i32);
+        assert_eq!(&dest[..src.len()], src);
+    }
+
+    #[test]
+    fn test_utf8_to_ascii() {
+        let src = b"Hello, \xC3\xA9world!";
+        let mut dest = [0u8; 20];
+
+        let result = change_utf8_encoding(&mut dest, src, src.len() as i32, Encoding::Line21);
+
+        assert_eq!(result, 14);
+        assert_eq!(&dest[..14], b"Hello, ?world!");
+    }
+
+    #[test]
+    fn test_unsupported_encoding() {
+        let src = b"Hello";
+        let mut dest = [0u8; 10];
+
+        let result = change_utf8_encoding(&mut dest, src, src.len() as i32, Encoding::UCS2);
+
+        assert_eq!(result, EncoderError::Unsupported as i32);
+    }
+    #[test]
+    fn test_ascii_to_ascii() {
+        let src = b"Hello World!";
+        let mut dest = Vec::with_capacity(20);
+        let result = change_ascii_encoding(&mut dest, src, Encoding::Line21);
+
+        assert_eq!(result.unwrap(), src.len());
+        assert_eq!(&dest[..src.len()], src);
+    }
+
+    #[test]
+    fn test_ascii_to_utf8() {
+        let src = b"Hello";
+        let mut dest = Vec::with_capacity(20);
+
+        let result = change_ascii_encoding(&mut dest, src, Encoding::UTF8);
+
+        assert_eq!(result.unwrap(), 5);
+        assert_eq!(&dest[..5], b"Hello");
+        assert_eq!(dest[5], 0);
+    }
+
+    #[test]
+    fn test_ascii_to_latin1() {
+        let src = b"Test";
+        let mut dest = Vec::with_capacity(20);
+
+        let result = change_ascii_encoding(&mut dest, src, Encoding::Latin1);
+
+        assert_eq!(result.unwrap(), 4);
+        assert_eq!(&dest[..4], b"Test");
+        assert_eq!(dest[4], 0);
+    }
+
+    #[test]
+    fn test_ascii_to_unicode() {
+        let src = b"Hi";
+        let mut dest = Vec::with_capacity(20);
+
+        let result = change_ascii_encoding(&mut dest, src, Encoding::UCS2);
+
+        assert_eq!(result.unwrap(), 4);
+        assert_eq!(dest[4], 0);
+    }
+
+    #[test]
+    fn test_get_str_basic_with_trim() {
+        let in_buffer = b"  Hello  \0";
+        let mut out_buffer = Vec::with_capacity(20);
+
+        let result = get_str_basic(
+            &mut out_buffer,
+            in_buffer,
+            true,
+            Encoding::Line21,
+            Encoding::Line21,
+            10,
+        );
+
+        assert!(result > 0);
+    }
+
+    #[test]
+    fn test_get_str_basic_without_trim() {
+        let in_buffer = b"  Hello  \0";
+        let mut out_buffer = Vec::with_capacity(20);
+
+        let result = get_str_basic(
+            &mut out_buffer,
+            in_buffer,
+            false,
+            Encoding::Line21,
+            Encoding::Line21,
+            10,
+        );
+
+        assert!(result > 0);
+    }
+}
diff --git a/src/rust/lib_ccxr/src/lib.rs b/src/rust/lib_ccxr/src/lib.rs
index 9f32678db..4b02a4dfa 100644
--- a/src/rust/lib_ccxr/src/lib.rs
+++ b/src/rust/lib_ccxr/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod activity;
 pub mod common;
+pub mod encoder;
 pub mod hardsubx;
 pub mod subtitle;
 pub mod teletext;
diff --git a/src/rust/lib_ccxr/src/util/encoding.rs b/src/rust/lib_ccxr/src/util/encoding.rs
index 6f0a77a35..e81db037e 100644
--- a/src/rust/lib_ccxr/src/util/encoding.rs
+++ b/src/rust/lib_ccxr/src/util/encoding.rs
@@ -4,8 +4,8 @@
 //! represented by [`Encoding`].
 //! - [`Line 21`](Encoding::Line21) - Used in 608 captions.
 //! - [`Latin-1`](Encoding::Latin1) - ISO/IEC 8859-1.
-//! - [`UCS-2`](Encoding::Ucs2) - UCS-2 code points.
-//! - [`UTF-8`](Encoding::Utf8)
+//! - [`UCS-2`](Encoding::UCS2) - UCS-2 code points.
+//! - [`UTF-8`](Encoding::UTF8)
 //!
 //! To represent a string in any one of the above encoding, use the following respectively.
 //! - [`Line21String`]
@@ -44,8 +44,8 @@ pub enum Encoding {
     Line21, // Same as `CCX_ENC_ASCII` in C
     Latin1, // Same as `CCX_ENC_LATIN_1` in C
     #[default]
-    Utf8, // Same as `CCX_ENC_UTF_8` in C
-    Ucs2,   // Same as `CCX_ENC_UNICODE` in C
+    UTF8, // Same as `CCX_ENC_UTF_8` in C
+    UCS2,   // Same as `CCX_ENC_UNICODE` in C
 }
 
 /// Represents a character in Line 21 encoding.
@@ -56,6 +56,8 @@ pub type Latin1Char = u8;
 
 /// Represents a character in UCS-2 encoding.
 pub type Ucs2Char = u16;
+/// Represents a character in UTF-8 encoding.
+pub type Utf8Char = u32;
 
 /// A String-like type containing a sequence of Line 21 encoded characters.
 #[derive(Clone, Debug, Eq, PartialEq, Default)]
@@ -115,8 +117,8 @@ impl Line21String {
         match encoding {
             Encoding::Line21 => self.clone().into(),
             Encoding::Latin1 => EncodedString::Latin1(self.into()),
-            Encoding::Ucs2 => EncodedString::Ucs2(self.into()),
-            Encoding::Utf8 => EncodedString::Utf8(self.into()),
+            Encoding::UCS2 => EncodedString::Ucs2(self.into()),
+            Encoding::UTF8 => EncodedString::Utf8(self.into()),
         }
     }
 
@@ -172,8 +174,8 @@ impl Latin1String {
         match encoding {
             Encoding::Line21 => EncodedString::Line21(self.into()),
             Encoding::Latin1 => self.clone().into(),
-            Encoding::Ucs2 => EncodedString::Ucs2(self.into()),
-            Encoding::Utf8 => EncodedString::Utf8(self.into()),
+            Encoding::UCS2 => EncodedString::Ucs2(self.into()),
+            Encoding::UTF8 => EncodedString::Utf8(self.into()),
         }
     }
 
@@ -229,8 +231,8 @@ impl Ucs2String {
         match encoding {
             Encoding::Line21 => EncodedString::Line21(self.into()),
             Encoding::Latin1 => EncodedString::Latin1(self.into()),
-            Encoding::Ucs2 => self.clone().into(),
-            Encoding::Utf8 => EncodedString::Utf8(self.into()),
+            Encoding::UCS2 => self.clone().into(),
+            Encoding::UTF8 => EncodedString::Utf8(self.into()),
         }
     }
 
@@ -339,7 +341,7 @@ impl From<&str> for Ucs2String {
 
 impl From<&Line21String> for String {
     fn from(value: &Line21String) -> String {
-        value.as_vec().iter().map(|&c| line21_to_utf8(c)).collect()
+        value.as_vec().iter().map(|&c| line21_to_char(c)).collect()
     }
 }
 
@@ -372,8 +374,8 @@ impl EncodedString {
         match encoding {
             Encoding::Line21 => EncodedString::Line21(string.into()),
             Encoding::Latin1 => EncodedString::Latin1(string.into()),
-            Encoding::Ucs2 => EncodedString::Ucs2(string.into()),
-            Encoding::Utf8 => EncodedString::Utf8(string.to_string()),
+            Encoding::UCS2 => EncodedString::Ucs2(string.into()),
+            Encoding::UTF8 => EncodedString::Utf8(string.to_string()),
         }
     }
 
@@ -389,8 +391,8 @@ impl EncodedString {
         match self {
             EncodedString::Line21(_) => Encoding::Line21,
             EncodedString::Latin1(_) => Encoding::Latin1,
-            EncodedString::Ucs2(_) => Encoding::Ucs2,
-            EncodedString::Utf8(_) => Encoding::Utf8,
+            EncodedString::Ucs2(_) => Encoding::UCS2,
+            EncodedString::Utf8(_) => Encoding::UTF8,
         }
     }
 
@@ -399,7 +401,7 @@ impl EncodedString {
     /// # Examples
     /// ```rust
     /// # use lib_ccxr::util::encoding::*;
-    /// let s = EncodedString::from_str("Hi 😀", Encoding::Ucs2);
+    /// let s = EncodedString::from_str("Hi 😀", Encoding::UCS2);
     /// assert_eq!(
     ///     s.to_line21(),
     ///     Line21String::from_vec(
@@ -421,7 +423,7 @@ impl EncodedString {
     /// # Examples
     /// ```rust
     /// # use lib_ccxr::util::encoding::*;
-    /// let s = EncodedString::from_str("résumé", Encoding::Utf8);
+    /// let s = EncodedString::from_str("résumé", Encoding::UTF8);
     /// assert_eq!(
     ///     s.to_latin1(),
     ///     Latin1String::from_vec(
@@ -480,20 +482,20 @@ impl EncodedString {
     }
 
     /// Converts this [`EncodedString`] to a format provided by `encoding`, returning a new [`EncodedString`].
-    ///    
+    ///
     /// # Examples
     /// ```rust
     /// # use lib_ccxr::util::encoding::*;
     /// let v = vec![0x72, 0x5c, 0x73, 0x75, 0x6d, 0x5c]; // résumé in Line 21 encoding
     /// let s: EncodedString = Line21String::from_vec(v).into();
-    /// assert_eq!(s.encode_to(Encoding::Utf8), "résumé".to_string().into())
+    /// assert_eq!(s.encode_to(Encoding::UTF8), "résumé".to_string().into())
     /// ```
     pub fn encode_to(&self, encoding: Encoding) -> EncodedString {
         match encoding {
             Encoding::Line21 => EncodedString::Line21(self.to_line21()),
             Encoding::Latin1 => EncodedString::Latin1(self.to_latin1()),
-            Encoding::Ucs2 => EncodedString::Ucs2(self.to_ucs2()),
-            Encoding::Utf8 => EncodedString::Utf8(self.to_utf8()),
+            Encoding::UCS2 => EncodedString::Ucs2(self.to_ucs2()),
+            Encoding::UTF8 => EncodedString::Utf8(self.to_utf8()),
         }
     }
 
@@ -653,7 +655,7 @@ fn latin1_to_line21(c: Latin1Char) -> Line21Char {
     }
 }
 
-fn line21_to_latin1(c: Line21Char) -> Latin1Char {
+pub fn line21_to_latin1(c: Line21Char) -> Latin1Char {
     if c < 0x80 {
         // Regular line-21 character set, mostly ASCII except these exceptions
         match c {
@@ -764,118 +766,139 @@ fn line21_to_latin1(c: Line21Char) -> Latin1Char {
     }
 }
 
-fn line21_to_utf8(c: Line21Char) -> char {
+pub fn line21_to_utf8(c: Line21Char) -> Utf8Char {
     if c < 0x80 {
         // Regular line-21 character set, mostly ASCII except these exceptions
         match c {
-            0x2a => 0xe1 as char, // lowercase a, acute accent
-            0x5c => 0xe9 as char, // lowercase e, acute accent
-            0x5e => 0xed as char, // lowercase i, acute accent
-            0x5f => 0xf3 as char, // lowercase o, acute accent
-            0x60 => 0xfa as char, // lowercase u, acute accent
-            0x7b => 0xe7 as char, // lowercase c with cedilla
-            0x7c => 0xf7 as char, // division symbol
-            0x7d => 0xd1 as char, // uppercase N tilde
-            0x7e => 0xf1 as char, // lowercase n tilde
-            0x7f => '■',          // Solid block
-            _ => c as char,
+            0x2a => 0xc3a1,   // lowercase a, acute accent
+            0x5c => 0xc3a9,   // lowercase e, acute accent
+            0x5e => 0xc3ad,   // lowercase i, acute accent
+            0x5f => 0xc3b3,   // lowercase o, acute accent
+            0x60 => 0xc3ba,   // lowercase u, acute accent
+            0x7b => 0xc3a7,   // lowercase c with cedilla
+            0x7c => 0xc3b7,   // division symbol
+            0x7d => 0xc391,   // uppercase N tilde
+            0x7e => 0xc3b1,   // lowercase n tilde
+            0x7f => 0xe296a0, // Solid block
+            _ => c as u32,    // Default: regular ASCII
         }
     } else {
         match c {
             // THIS BLOCK INCLUDES THE 16 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
             // THAT COME FROM HI BYTE=0x11 AND LOW BETWEEN 0x30 AND 0x3F
-            0x80 => 0xae as char, // Registered symbol (R)
-            0x81 => 0xb0 as char, // degree sign
-            0x82 => 0xbd as char, // 1/2 symbol
-            0x83 => 0xbf as char, // Inverted (open) question mark
-            0x84 => '™',          // Trademark symbol (TM)
-            0x85 => 0xa2 as char, // Cents symbol
-            0x86 => 0xa3 as char, // Pounds sterling
-            0x87 => 0xb6 as char, // Music note - Not in latin 1, so we use 'pilcrow'
-            0x88 => 0xe0 as char, // lowercase a, grave accent
-            0x89 => 0x20 as char, // transparent space, we make it regular
-            0x8a => 0xe8 as char, // lowercase e, grave accent
-            0x8b => 0xe2 as char, // lowercase a, circumflex accent
-            0x8c => 0xea as char, // lowercase e, circumflex accent
-            0x8d => 0xee as char, // lowercase i, circumflex accent
-            0x8e => 0xf4 as char, // lowercase o, circumflex accent
-            0x8f => 0xfb as char, // lowercase u, circumflex accent
+            0x80 => 0xc2ae,   // Registered symbol (R)
+            0x81 => 0xc2b0,   // degree sign
+            0x82 => 0xc2bd,   // 1/2 symbol
+            0x83 => 0xc2bf,   // Inverted (open) question mark
+            0x84 => 0xe284a2, // Trademark symbol (TM)
+            0x85 => 0xc2a2,   // Cents symbol
+            0x86 => 0xc2a3,   // Pounds sterling
+            0x87 => 0xe299aa, // Music note
+            0x88 => 0xc3a0,   // lowercase a, grave accent
+            0x89 => 0x20,     // transparent space, we make it regular
+            0x8a => 0xc3a8,   // lowercase e, grave accent
+            0x8b => 0xc3a2,   // lowercase a, circumflex accent
+            0x8c => 0xc3aa,   // lowercase e, circumflex accent
+            0x8d => 0xc3ae,   // lowercase i, circumflex accent
+            0x8e => 0xc3b4,   // lowercase o, circumflex accent
+            0x8f => 0xc3bb,   // lowercase u, circumflex accent
             // THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
             // THAT COME FROM HI BYTE=0x12 AND LOW BETWEEN 0x20 AND 0x3F
-            0x90 => 0xc1 as char, // capital letter A with acute
-            0x91 => 0xc9 as char, // capital letter E with acute
-            0x92 => 0xd3 as char, // capital letter O with acute
-            0x93 => 0xda as char, // capital letter U with acute
-            0x94 => 0xdc as char, // capital letter U with diaeresis
-            0x95 => 0xfc as char, // lowercase letter U with diaeresis
-            0x96 => 0x27 as char, // apostrophe
-            0x97 => 0xa1 as char, // inverted exclamation mark
-            0x98 => 0x2a as char, // asterisk
-            0x99 => 0x27 as char, // apostrophe (yes, duped). See CCADI source code.
-            0x9a => 0x2d as char, // em dash
-            0x9b => 0xa9 as char, // copyright sign
-            0x9c => '℠',          // Service Mark
-            0x9d => 0x2e as char, // Full stop (.)
-            0x9e => 0x22 as char, // Quotation mark
-            0x9f => 0x22 as char, // Quotation mark
-            0xa0 => 0xc0 as char, // uppercase A, grave accent
-            0xa1 => 0xc2 as char, // uppercase A, circumflex
-            0xa2 => 0xc7 as char, // uppercase C with cedilla
-            0xa3 => 0xc8 as char, // uppercase E, grave accent
-            0xa4 => 0xca as char, // uppercase E, circumflex
-            0xa5 => 0xcb as char, // capital letter E with diaeresis
-            0xa6 => 0xeb as char, // lowercase letter e with diaeresis
-            0xa7 => 0xce as char, // uppercase I, circumflex
-            0xa8 => 0xcf as char, // uppercase I, with diaeresis
-            0xa9 => 0xef as char, // lowercase i, with diaeresis
-            0xaa => 0xd4 as char, // uppercase O, circumflex
-            0xab => 0xd9 as char, // uppercase U, grave accent
-            0xac => 0xf9 as char, // lowercase u, grave accent
-            0xad => 0xdb as char, // uppercase U, circumflex
-            0xae => 0xab as char, // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
-            0xaf => 0xbb as char, // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+            0x90 => 0xc381,   // capital letter A with acute
+            0x91 => 0xc389,   // capital letter E with acute
+            0x92 => 0xc393,   // capital letter O with acute
+            0x93 => 0xc39a,   // capital letter U with acute
+            0x94 => 0xc39c,   // capital letter U with diaeresis
+            0x95 => 0xc3bc,   // lowercase letter U with diaeresis
+            0x96 => 0x27,     // apostrophe
+            0x97 => 0xc2a1,   // inverted exclamation mark
+            0x98 => 0x2a,     // asterisk
+            0x99 => 0x27,     // Plain single quote
+            0x9a => 0xe28094, // em dash
+            0x9b => 0xc2a9,   // copyright sign
+            0x9c => 0xe284a0, // Service mark
+            0x9d => 0xe280a2, // Round bullet
+            0x9e => 0xe2809c, // Opening double quotes
+            0x9f => 0xe2809d, // Closing double quotes
+            0xa0 => 0xc380,   // uppercase A, grave accent
+            0xa1 => 0xc382,   // uppercase A, circumflex
+            0xa2 => 0xc387,   // uppercase C with cedilla
+            0xa3 => 0xc388,   // uppercase E, grave accent
+            0xa4 => 0xc38a,   // uppercase E, circumflex
+            0xa5 => 0xc38b,   // capital letter E with diaeresis
+            0xa6 => 0xc3ab,   // lowercase letter e with diaeresis
+            0xa7 => 0xc38e,   // uppercase I, circumflex
+            0xa8 => 0xc38f,   // uppercase I, with diaeresis
+            0xa9 => 0xc3af,   // lowercase i, with diaeresis
+            0xaa => 0xc394,   // uppercase O, circumflex
+            0xab => 0xc399,   // uppercase U, grave accent
+            0xac => 0xc3b9,   // lowercase u, grave accent
+            0xad => 0xc39b,   // uppercase U, circumflex
+            0xae => 0xc2ab,   // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+            0xaf => 0xc2bb,   // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+
             // THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
             // THAT COME FROM HI BYTE=0x13 AND LOW BETWEEN 0x20 AND 0x3F
-            0xb0 => 0xc3 as char, // Uppercase A, tilde
-            0xb1 => 0xe3 as char, // Lowercase a, tilde
-            0xb2 => 0xcd as char, // Uppercase I, acute accent
-            0xb3 => 0xcc as char, // Uppercase I, grave accent
-            0xb4 => 0xec as char, // Lowercase i, grave accent
-            0xb5 => 0xd2 as char, // Uppercase O, grave accent
-            0xb6 => 0xf2 as char, // Lowercase o, grave accent
-            0xb7 => 0xd5 as char, // Uppercase O, tilde
-            0xb8 => 0xf5 as char, // Lowercase o, tilde
-            0xb9 => 0x7b as char, // Open curly brace
-            0xba => 0x7d as char, // Closing curly brace
-            0xbb => 0x5c as char, // Backslash
-            0xbc => 0x5e as char, // Caret
-            0xbd => 0x5f as char, // Underscore
-            0xbe => 0xa6 as char, // Pipe (broken bar)
-            0xbf => 0x7e as char, // Tilde
-            0xc0 => 0xc4 as char, // Uppercase A, umlaut
-            0xc1 => 0xe3 as char, // Lowercase A, umlaut
-            0xc2 => 0xd6 as char, // Uppercase O, umlaut
-            0xc3 => 0xf6 as char, // Lowercase o, umlaut
-            0xc4 => 0xdf as char, // Eszett (sharp S)
-            0xc5 => 0xa5 as char, // Yen symbol
-            0xc6 => 0xa4 as char, // Currency symbol
-            0xc7 => 0x7c as char, // Vertical bar
-            0xc8 => 0xc5 as char, // Uppercase A, ring
-            0xc9 => 0xe5 as char, // Lowercase A, ring
-            0xca => 0xd8 as char, // Uppercase O, slash
-            0xcb => 0xf8 as char, // Lowercase o, slash
-            0xcc => '⌜',          // Top left corner
-            0xcd => '⌝',          // Top right corner
-            0xce => '⌞',          // Bottom left corner
-            0xcf => '⌟',          // Bottom right corner
-            _ => UNAVAILABLE_CHAR as char, // For those that don't have representation
-                                   // I'll do it eventually, I promise
-                                   // This are weird chars anyway
+            0xb0 => 0xc383,   // Uppercase A, tilde
+            0xb1 => 0xc3a3,   // Lowercase a, tilde
+            0xb2 => 0xc38d,   // Uppercase I, acute accent
+            0xb3 => 0xc38c,   // Uppercase I, grave accent
+            0xb4 => 0xc3ac,   // Lowercase i, grave accent
+            0xb5 => 0xc392,   // Uppercase O, grave accent
+            0xb6 => 0xc3b2,   // Lowercase o, grave accent
+            0xb7 => 0xc395,   // Uppercase O, tilde
+            0xb8 => 0xc3b5,   // Lowercase o, tilde
+            0xb9 => 0x7b,     // Open curly brace
+            0xba => 0x7d,     // Closing curly brace
+            0xbb => 0x5c,     // Backslash
+            0xbc => 0x5e,     // Caret
+            0xbd => 0x5f,     // Underscore
+            0xbe => 0xc2a6,   // Pipe (broken bar)
+            0xbf => 0x7e,     // Tilde
+            0xc0 => 0xc384,   // Uppercase A, umlaut
+            0xc1 => 0xc3a4,   // Lowercase A, umlaut
+            0xc2 => 0xc396,   // Uppercase O, umlaut
+            0xc3 => 0xc3b6,   // Lowercase o, umlaut
+            0xc4 => 0xc39f,   // Esszett (sharp S)
+            0xc5 => 0xc2a5,   // Yen symbol
+            0xc6 => 0xc2a4,   // Currency symbol
+            0xc7 => 0x7c,     // Vertical bar
+            0xc8 => 0xc385,   // Uppercase A, ring
+            0xc9 => 0xc3a5,   // Lowercase A, ring
+            0xca => 0xc398,   // Uppercase O, slash
+            0xcb => 0xc3b8,   // Lowercase o, slash
+            0xcc => 0xe28c9c, // Top left corner
+            0xcd => 0xe28c9d, // Top right corner
+            0xce => 0xe28c9e, // Bottom left corner
+            0xcf => 0xe28c9f, // Bottom right corner
+            _ => b'?' as u32, // I'll do it eventually, I promise
+                               // This are weird chars anyway
         }
     }
 }
+pub fn line21_to_char(c: Line21Char) -> char {
+    let utf8_packed = line21_to_utf8(c);
+
+    let bytes = if utf8_packed <= 0xff {
+        vec![utf8_packed as u8]
+    } else if utf8_packed <= 0xffff {
+        vec![(utf8_packed >> 8) as u8, utf8_packed as u8]
+    } else if utf8_packed <= 0xffffff {
+        vec![
+            (utf8_packed >> 16) as u8,
+            (utf8_packed >> 8) as u8,
+            utf8_packed as u8,
+        ]
+    } else {
+        return '?';
+    };
 
-fn line21_to_ucs2(c: Line21Char) -> Ucs2Char {
+    std::str::from_utf8(&bytes)
+        .ok()
+        .and_then(|s| s.chars().next())
+        .unwrap_or('?')
+}
+pub fn line21_to_ucs2(c: Line21Char) -> Ucs2Char {
     match c {
         0x7f => 0x25A0,                  // Solid block
         0x84 => 0x2122,                  // Trademark symbol (TM)
@@ -905,7 +928,7 @@ fn ucs2_to_line21(c: Ucs2Char) -> Line21Char {
     }
 }
 
-fn ucs2_to_latin1(c: Ucs2Char) -> Latin1Char {
+pub fn ucs2_to_latin1(c: Ucs2Char) -> Latin1Char {
     // Code points 0 to U+00FF are the same in both.
     if c < 0xff {
         c as u8
@@ -1004,6 +1027,6 @@ fn ucs2_to_char(c: Ucs2Char) -> char {
     char::from_u32(x).unwrap_or(UNAVAILABLE_CHAR.into())
 }
 
-fn char_to_ucs2(c: char) -> Ucs2Char {
+pub fn char_to_ucs2(c: char) -> Ucs2Char {
     (c as u32).try_into().unwrap_or(UNAVAILABLE_CHAR.into())
 }
diff --git a/src/rust/src/common.rs b/src/rust/src/common.rs
index b182c5020..4de6dd7e0 100644
--- a/src/rust/src/common.rs
+++ b/src/rust/src/common.rs
@@ -352,8 +352,8 @@ impl CType<u32> for Encoding {
         match self {
             Encoding::Line21 => ccx_encoding_type_CCX_ENC_ASCII as _,
             Encoding::Latin1 => ccx_encoding_type_CCX_ENC_LATIN_1 as _,
-            Encoding::Utf8 => ccx_encoding_type_CCX_ENC_UTF_8 as _,
-            Encoding::Ucs2 => ccx_encoding_type_CCX_ENC_UNICODE as _,
+            Encoding::UTF8 => ccx_encoding_type_CCX_ENC_UTF_8 as _,
+            Encoding::UCS2 => ccx_encoding_type_CCX_ENC_UNICODE as _,
         }
     }
 }
diff --git a/src/rust/src/encoder/common.rs b/src/rust/src/encoder/common.rs
new file mode 100644
index 000000000..91d2b163e
--- /dev/null
+++ b/src/rust/src/encoder/common.rs
@@ -0,0 +1,420 @@
+#![allow(dead_code)]
+use crate::bindings::{
+    ccx_encoding_type_CCX_ENC_UNICODE, ccx_s_write, encoder_ctx, net_send_header,
+    write_spumux_footer, write_spumux_header,
+};
+use crate::ccx_options;
+use crate::encoder::FromCType;
+use lib_ccxr::common::{OutputFormat, BROADCAST_HEADER, LITTLE_ENDIAN_BOM, UTF8_BOM};
+use lib_ccxr::util::encoding::Encoding;
+use lib_ccxr::util::log::DebugMessageFlag;
+use lib_ccxr::{debug, info};
+use std::alloc::{alloc, dealloc, Layout};
+use std::fs::File;
+use std::io::Write;
+#[cfg(unix)]
+use std::os::fd::FromRawFd;
+use std::os::raw::{c_int, c_uchar, c_uint, c_void};
+#[cfg(windows)]
+use std::os::windows::io::FromRawHandle;
+use std::ptr;
+
+const CCD_HEADER: &[u8] = b"SCC_disassembly V1.2";
+const SCC_HEADER: &[u8] = b"Scenarist_SCC V1.0";
+
+const SSA_HEADER: &str = "[Script Info]\n\
+Title: Default file\n\
+ScriptType: v4.00+\n\
+\n\
+[V4+ Styles]\n\
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n\
+Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,1,1,2,10,10,10,0\n\
+\n\
+[Events]\n\
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n\
+\n";
+const SAMI_HEADER: &str = "<SAMI>\n\
+<HEAD>\n\
+<STYLE TYPE=\"text/css\">\n\
+<!--\n\
+P {margin-left: 16pt; margin-right: 16pt; margin-bottom: 16pt; margin-top: 16pt;\n\
+text-align: center; font-size: 18pt; font-family: arial; font-weight: bold; color: #f0f0f0;}\n\
+.UNKNOWNCC {Name:Unknown; lang:en-US; SAMIType:CC;}\n\
+-->\n\
+</STYLE>\n\
+</HEAD>\n\n\
+<BODY>\n";
+const SMPTETT_HEADER: &str = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n  <tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttp=\"http://www.w3.org/ns/ttml#parameter\" ttp:dropMode=\"dropNTSC\" ttp:frameRate=\"30\" ttp:frameRateMultiplier=\"1000 1001\" ttp:timeBase=\"smpte\" xmlns:m608=\"http://www.smpte-ra.org/schemas/2052-1/2010/smpte-tt#cea608\" xmlns:smpte=\"http://www.smpte-ra.org/schemas/2052-1/2010/smpte-tt\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\" xmlns:tts=\"http://www.w3.org/ns/ttml#styling\">\n  <head>\n    <styling>\n      <style tts:color=\"white\" tts:fontFamily=\"monospace\" tts:fontWeight=\"normal\" tts:textAlign=\"left\" xml:id=\"basic\"/>\n    </styling>\n    <layout>\n      <region tts:backgroundColor=\"transparent\" xml:id=\"pop1\"/>\n      <region tts:backgroundColor=\"transparent\" xml:id=\"paint\"/>\n      <region tts:backgroundColor=\"transparent\" xml:id=\"rollup2\"/>\n      <region tts:backgroundColor=\"transparent\" xml:id=\"rollup3\"/>\n      <region tts:backgroundColor=\"transparent\" xml:id=\"rollup4\"/>\n    </layout>\n    <metadata/>\n    <smpte:information m608:captionService=\"F1C1CC\" m608:channel=\"cc1\"/>\n  </head>\n  <body>\n    <div>\n";
+const SIMPLE_XML_HEADER: &str = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<captions>\n";
+
+const WEBVTT_HEADER: &[&str] = &["WEBVTT\n", "\n", "\n"];
+
+const RCWT_HEADER: &[u8] = &[0xCC, 0xCC, 0xED, 0xCC, 0x00, 0x50, 0, 1, 0, 0, 0]; // "RCWT" + version
+
+pub fn encode_line(ctx: &mut encoder_ctx, buffer: &mut [c_uchar], text: &[u8]) -> c_uint {
+    if buffer.is_empty() {
+        return 0;
+    }
+
+    let mut bytes: c_uint = 0;
+    let mut buffer_pos = 0;
+    let mut text_pos = 0;
+    let text_len = text.iter().position(|&b| b == 0).unwrap_or(text.len());
+    while text_pos < text_len {
+        let current_byte = text[text_pos];
+        let enc = unsafe { Encoding::from_ctype(ctx.encoding).unwrap_or(Encoding::default()) };
+        match enc {
+            Encoding::UTF8 | Encoding::Latin1 => {
+                if buffer_pos + 1 >= buffer.len() {
+                    break;
+                }
+
+                buffer[buffer_pos] = current_byte;
+                bytes += 1;
+                buffer_pos += 1;
+            }
+
+            Encoding::UCS2 => {
+                if buffer_pos + 2 >= buffer.len() {
+                    break;
+                }
+
+                buffer[buffer_pos] = current_byte;
+                buffer[buffer_pos + 1] = 0;
+                bytes += 2;
+                buffer_pos += 2;
+            }
+            _ => {}
+        }
+        text_pos += 1;
+    }
+
+    // Add null terminator if there's space
+    if buffer_pos < buffer.len() {
+        buffer[buffer_pos] = 0;
+    }
+
+    bytes
+}
+pub fn write_subtitle_file_footer(ctx: &mut encoder_ctx, out: &mut ccx_s_write) -> c_int {
+    let mut ret: c_int = 0;
+    let mut str_buffer = [0u8; 1024];
+    let write_format =
+        unsafe { OutputFormat::from_ctype(ctx.write_format).unwrap_or(OutputFormat::Raw) };
+
+    match write_format {
+        OutputFormat::Sami | OutputFormat::SmpteTt | OutputFormat::SimpleXml => {
+            let footer: &[u8] = match write_format {
+                OutputFormat::Sami => b"</BODY></SAMI>\n\0",
+                OutputFormat::SmpteTt => b"    </div>\n  </body>\n</tt>\n\0",
+                OutputFormat::SimpleXml => b"</captions>\n\0",
+                _ => unreachable!(),
+            };
+
+            // Bounds check for str_buffer
+            if footer.len() > str_buffer.len() {
+                return -1;
+            }
+
+            str_buffer[..footer.len()].copy_from_slice(footer);
+
+            if ctx.encoding != ccx_encoding_type_CCX_ENC_UNICODE {
+                debug!(msg_type = DebugMessageFlag::DECODER_608; "\r{}\n",
+                    std::str::from_utf8(&str_buffer[..footer.len()-1]).unwrap_or(""));
+            }
+
+            // Create safe slice from buffer pointer and capacity
+            let buffer_slice =
+                unsafe { std::slice::from_raw_parts_mut(ctx.buffer, ctx.capacity as usize) };
+            let text_slice = &str_buffer[..footer.len()];
+            let used = encode_line(ctx, buffer_slice, text_slice);
+
+            // Bounds check for buffer access
+            if used > ctx.capacity {
+                return -1;
+            }
+
+            ret = write_raw(out.fh, ctx.buffer as *const c_void, used as usize) as c_int;
+
+            if ret != used as c_int {
+                info!("WARNING: loss of data\n");
+            }
+        }
+
+        OutputFormat::SpuPng => unsafe {
+            write_spumux_footer(out);
+        },
+
+        OutputFormat::Scc | OutputFormat::Ccd => {
+            // Bounds check for encoded_crlf access
+            if ctx.encoded_crlf_length as usize > ctx.encoded_crlf.len() {
+                return -1;
+            }
+
+            ret = write_raw(
+                out.fh,
+                ctx.encoded_crlf.as_ptr() as *const c_void,
+                ctx.encoded_crlf_length as usize,
+            ) as c_int;
+        }
+
+        _ => {
+            // Nothing to do, no footer on this format
+        }
+    }
+
+    ret
+}
+pub fn write_raw(fd: c_int, buf: *const c_void, count: usize) -> isize {
+    if buf.is_null() || count == 0 {
+        return 0;
+    }
+    #[cfg(unix)]
+    let mut file = unsafe { File::from_raw_fd(fd) };
+    #[cfg(windows)]
+    let mut file = unsafe { File::from_raw_handle(fd as _) };
+    let data = unsafe { std::slice::from_raw_parts(buf as *const u8, count) };
+    let result = match file.write(data) {
+        Ok(bytes_written) => bytes_written as isize,
+        Err(_) => -1,
+    };
+    std::mem::forget(file);
+    result
+}
+
+fn request_buffer_capacity(ctx: &mut encoder_ctx, length: c_uint) -> bool {
+    if length > ctx.capacity {
+        let old_capacity = ctx.capacity;
+        ctx.capacity = length * 2;
+
+        // Allocate new buffer
+        let new_layout = Layout::from_size_align(ctx.capacity as usize, align_of::<u8>()).unwrap();
+
+        let new_buffer = unsafe { alloc(new_layout) };
+
+        if new_buffer.is_null() {
+            // In C this would call: fatal(EXIT_NOT_ENOUGH_MEMORY, "Not enough memory for reallocating buffer, bailing out\n");
+            return false;
+        }
+
+        // Copy old data if buffer existed
+        if !ctx.buffer.is_null() && old_capacity > 0 {
+            unsafe {
+                ptr::copy_nonoverlapping(ctx.buffer, new_buffer, old_capacity as usize);
+            }
+
+            // Deallocate old buffer
+            let old_layout =
+                Layout::from_size_align(old_capacity as usize, std::mem::align_of::<u8>()).unwrap();
+
+            unsafe {
+                dealloc(ctx.buffer, old_layout);
+            }
+        }
+
+        ctx.buffer = new_buffer;
+    }
+
+    true
+}
+pub fn write_bom(ctx: &mut encoder_ctx, out: &mut ccx_s_write) -> c_int {
+    let mut ret: c_int = 0;
+
+    if ctx.no_bom == 0 {
+        let enc = unsafe { Encoding::from_ctype(ctx.encoding).unwrap_or(Encoding::default()) };
+        match enc {
+            Encoding::UTF8 => {
+                ret =
+                    write_raw(out.fh, UTF8_BOM.as_ptr() as *const c_void, UTF8_BOM.len()) as c_int;
+                if ret < UTF8_BOM.len() as c_int {
+                    info!("WARNING: Unable to write UTF BOM\n");
+                    return -1;
+                }
+            }
+            Encoding::UCS2 => {
+                ret = write_raw(
+                    out.fh,
+                    LITTLE_ENDIAN_BOM.as_ptr() as *const c_void,
+                    LITTLE_ENDIAN_BOM.len(),
+                ) as c_int;
+                if ret < LITTLE_ENDIAN_BOM.len() as c_int {
+                    info!("WARNING: Unable to write LITTLE_ENDIAN_BOM\n");
+                    return -1;
+                }
+            }
+            _ => {}
+        }
+    }
+
+    ret
+}
+
+pub fn write_subtitle_file_header(ctx: &mut encoder_ctx, out: &mut ccx_s_write) -> c_int {
+    let mut used: c_uint;
+    let mut header_size: usize = 0;
+    let write_format =
+        unsafe { OutputFormat::from_ctype(ctx.write_format).unwrap_or(OutputFormat::Raw) };
+
+    match write_format {
+        OutputFormat::Ccd => {
+            if write_raw(
+                out.fh,
+                CCD_HEADER.as_ptr() as *const c_void,
+                CCD_HEADER.len() - 1,
+            ) == -1
+                || write_raw(
+                    out.fh,
+                    ctx.encoded_crlf.as_ptr() as *const c_void,
+                    ctx.encoded_crlf_length as usize,
+                ) == -1
+            {
+                info!("Unable to write CCD header to file\n");
+                return -1;
+            }
+        }
+
+        OutputFormat::Scc => {
+            if write_raw(
+                out.fh,
+                SCC_HEADER.as_ptr() as *const c_void,
+                SCC_HEADER.len() - 1,
+            ) == -1
+            {
+                info!("Unable to write SCC header to file\n");
+                return -1;
+            }
+        }
+
+        OutputFormat::Srt
+        | OutputFormat::G608
+        | OutputFormat::SpuPng
+        | OutputFormat::Transcript => {
+            if write_bom(ctx, out) < 0 {
+                return -1;
+            }
+            if write_format == OutputFormat::SpuPng {
+                unsafe {
+                    write_spumux_header(ctx, out);
+                }
+            }
+        }
+
+        OutputFormat::Ssa
+        | OutputFormat::Sami
+        | OutputFormat::SmpteTt
+        | OutputFormat::SimpleXml => {
+            if write_bom(ctx, out) < 0 {
+                return -1;
+            }
+
+            let header_data = match write_format {
+                OutputFormat::Ssa => SSA_HEADER,
+                OutputFormat::Sami => SAMI_HEADER,
+                OutputFormat::SmpteTt => SMPTETT_HEADER,
+                OutputFormat::SimpleXml => SIMPLE_XML_HEADER,
+                _ => unreachable!(),
+            };
+
+            if !request_buffer_capacity(ctx, (header_data.len() * 3) as c_uint) {
+                return -1;
+            }
+
+            // Create safe slice from buffer pointer and capacity
+            let buffer_slice =
+                unsafe { std::slice::from_raw_parts_mut(ctx.buffer, ctx.capacity as usize) };
+            let text_slice = header_data;
+            used = encode_line(ctx, buffer_slice, text_slice.as_ref());
+
+            if used > ctx.capacity {
+                return -1;
+            }
+
+            if write_raw(out.fh, ctx.buffer as *const c_void, used as usize) < used as isize {
+                info!("WARNING: Unable to write complete Buffer\n");
+                return -1;
+            }
+        }
+
+        OutputFormat::WebVtt => {
+            if write_bom(ctx, out) < 0 {
+                return -1;
+            }
+
+            // Calculate total header size
+            for header_line in WEBVTT_HEADER {
+                header_size += header_line.len();
+            }
+
+            if !request_buffer_capacity(ctx, (header_size * 3) as c_uint) {
+                return -1;
+            }
+
+            for header_line in WEBVTT_HEADER {
+                let line_to_write = unsafe {
+                    if ccx_options.enc_cfg.line_terminator_lf == 1 && *header_line == "\r\n" {
+                        // If -lf parameter passed, write LF instead of CRLF
+                        "\n"
+                    } else {
+                        header_line
+                    }
+                };
+
+                // Create safe slice from buffer pointer and capacity
+                let buffer_slice =
+                    unsafe { std::slice::from_raw_parts_mut(ctx.buffer, ctx.capacity as usize) };
+                let text_slice = line_to_write.as_bytes();
+                used = encode_line(ctx, buffer_slice, text_slice);
+
+                if used > ctx.capacity {
+                    return -1;
+                }
+
+                if write_raw(out.fh, ctx.buffer as *const c_void, used as usize) < used as isize {
+                    info!("WARNING: Unable to write complete Buffer\n");
+                    return -1;
+                }
+            }
+        }
+
+        OutputFormat::Rcwt => {
+            let mut rcwt_header = RCWT_HEADER.to_vec();
+            rcwt_header[7] = ctx.in_fileformat as u8; // sets file format version
+
+            if ctx.send_to_srv != 0 {
+                unsafe {
+                    net_send_header(rcwt_header.as_ptr(), rcwt_header.len());
+                }
+            } else if write_raw(
+                out.fh,
+                rcwt_header.as_ptr() as *const c_void,
+                rcwt_header.len(),
+            ) < 0
+            {
+                info!("Unable to write rcwt header\n");
+                return -1;
+            }
+        }
+
+        OutputFormat::Raw => {
+            if write_raw(
+                out.fh,
+                BROADCAST_HEADER.as_ptr() as *const c_void,
+                BROADCAST_HEADER.len(),
+            ) < BROADCAST_HEADER.len() as isize
+            {
+                info!("Unable to write Raw header\n");
+                return -1;
+            }
+        }
+
+        OutputFormat::Mcc => {
+            ctx.header_printed_flag = 0;
+        }
+
+        _ => {
+            // Default case - do nothing
+        }
+    }
+
+    0
+}
diff --git a/src/rust/src/encoder/g608.rs b/src/rust/src/encoder/g608.rs
new file mode 100644
index 000000000..9399968ad
--- /dev/null
+++ b/src/rust/src/encoder/g608.rs
@@ -0,0 +1,253 @@
+use crate::bindings::{
+    eia608_screen, encoder_ctx, font_bits_FONT_ITALICS, font_bits_FONT_REGULAR,
+    font_bits_FONT_UNDERLINED, font_bits_FONT_UNDERLINED_ITALICS,
+};
+use crate::encoder::common::{encode_line, write_raw};
+use crate::encoder::FromCType;
+use crate::libccxr_exports::time::ccxr_millis_to_time;
+use lib_ccxr::util::encoding::{line21_to_latin1, line21_to_ucs2, line21_to_utf8, Encoding};
+use std::io;
+use std::os::raw::{c_int, c_uchar, c_uint, c_void};
+
+/// Write data to file descriptor with retry logic
+pub fn write_wrapped(fd: c_int, buf: &[u8]) -> Result<(), io::Error> {
+    let mut remaining = buf.len();
+    let mut current_buf = buf.as_ptr();
+
+    while remaining > 0 {
+        let written = write_raw(fd, current_buf as *const c_void, remaining);
+        if written == -1 {
+            return Err(io::Error::last_os_error());
+        }
+        unsafe {
+            current_buf = current_buf.add(written as usize);
+        }
+        remaining -= written as usize;
+    }
+
+    Ok(())
+}
+
+/// Get line characters encoded according to context encoding
+pub fn get_line_encoded(
+    ctx: &encoder_ctx,
+    buffer: &mut [c_uchar],
+    line_num: usize,
+    data: &eia608_screen,
+) -> c_uint {
+    let mut buffer_pos = 0;
+    let line = &data.characters[line_num];
+
+    for i in line.iter().take(33) {
+        let enc = unsafe { Encoding::from_ctype(ctx.encoding).unwrap_or(Encoding::default()) };
+        let bytes_written = match enc {
+            Encoding::UTF8 => {
+                let utf8_char = line21_to_utf8(*i);
+                let first_non_zero = (utf8_char.leading_zeros() / 8) as usize;
+                let bytes = utf8_char.to_be_bytes(); // UTF-8, big-endian
+                                                     // Since we use u32, it would have leading zeroes
+                let byte_count = bytes.len() - first_non_zero;
+                if buffer_pos + byte_count > buffer.len() {
+                    return 0;
+                }
+                buffer[buffer_pos..(byte_count + buffer_pos)]
+                    .copy_from_slice(&bytes[first_non_zero..(first_non_zero + byte_count)]);
+                byte_count
+            }
+            Encoding::Latin1 => {
+                if buffer_pos < buffer.len() {
+                    let latin1_char = line21_to_latin1(*i);
+                    buffer[buffer_pos] = latin1_char as c_uchar;
+                    1
+                } else {
+                    0
+                }
+            }
+            Encoding::UCS2 => {
+                if buffer_pos + 1 < buffer.len() {
+                    let ucs2_char = line21_to_ucs2(*i);
+                    // UCS-2 is 2 bytes, little-endian
+                    let bytes = ucs2_char.to_le_bytes();
+                    buffer[buffer_pos] = bytes[0] as c_uchar;
+                    buffer[buffer_pos + 1] = bytes[1] as c_uchar;
+                    2
+                } else {
+                    0
+                }
+            }
+            Encoding::Line21 => {
+                if buffer_pos < buffer.len() {
+                    buffer[buffer_pos] = *i;
+                    1
+                } else {
+                    0
+                }
+            }
+        };
+
+        buffer_pos += bytes_written;
+
+        // Break if we've run out of buffer space
+        if bytes_written == 0 {
+            break;
+        }
+    }
+
+    buffer_pos as c_uint
+}
+/// Get color information encoded as characters
+pub fn get_color_encoded(
+    _ctx: &encoder_ctx,
+    buffer: &mut [c_uchar],
+    line_num: usize,
+    data: &eia608_screen,
+) -> c_uint {
+    let mut buffer_pos = 0;
+    for i in 0..32 {
+        if buffer_pos >= buffer.len() {
+            break;
+        }
+        let color_val = data.colors[line_num][i] as u8;
+        buffer[buffer_pos] = if color_val < 10 {
+            color_val + b'0'
+        } else {
+            b'E'
+        };
+        buffer_pos += 1;
+    }
+    if buffer_pos < buffer.len() {
+        buffer[buffer_pos] = 0;
+    }
+    buffer_pos as c_uint
+}
+
+/// Get font information encoded as characters
+pub fn get_font_encoded(
+    _ctx: &encoder_ctx,
+    buffer: &mut [c_uchar],
+    line_num: usize,
+    data: &eia608_screen,
+) -> c_uint {
+    let mut buffer_pos = 0;
+
+    for i in 0..32 {
+        if buffer_pos >= buffer.len() {
+            break;
+        }
+
+        let font_val = data.fonts[line_num][i];
+        buffer[buffer_pos] = match font_val {
+            font_bits_FONT_REGULAR => b'R',
+            font_bits_FONT_UNDERLINED_ITALICS => b'B',
+            font_bits_FONT_UNDERLINED => b'U',
+            font_bits_FONT_ITALICS => b'I',
+            _ => b'E',
+        };
+        buffer_pos += 1;
+    }
+
+    buffer_pos as c_uint
+}
+
+/// Write CC buffer in G608 format
+pub fn write_cc_buffer_as_g608(data: &eia608_screen, context: &mut encoder_ctx) -> c_int {
+    let mut wrote_something = 0;
+
+    // Convert start and end times
+    let mut h1: u32 = 0;
+    let mut m1: u32 = 0;
+    let mut s1: u32 = 0;
+    let mut ms1: u32 = 0;
+
+    let mut h2: u32 = 0;
+    let mut m2: u32 = 0;
+    let mut s2: u32 = 0;
+    let mut ms2: u32 = 0;
+
+    unsafe {
+        ccxr_millis_to_time(data.start_time, &mut h1, &mut m1, &mut s1, &mut ms1);
+        ccxr_millis_to_time(data.end_time - 1, &mut h2, &mut m2, &mut s2, &mut ms2);
+        // -1 To prevent overlapping with the next line.
+    }
+
+    // Increment counter
+    context.srt_counter += 1;
+    let encoded_clrf = unsafe {
+        std::str::from_utf8_unchecked(std::slice::from_raw_parts(
+            context.encoded_crlf.as_ptr(),
+            context.encoded_crlf_length as usize,
+        ))
+    };
+    // Create timeline string for counter
+    let counter_line = format!("{}{}", context.srt_counter, encoded_clrf);
+
+    // Encode and write counter line
+    let buffer_slice =
+        unsafe { std::slice::from_raw_parts_mut(context.buffer, context.capacity as usize) };
+    let used = encode_line(context, buffer_slice, counter_line.as_bytes());
+
+    if write_wrapped(unsafe { (*context.out).fh }, &buffer_slice[..used as usize]).is_err() {
+        return 0;
+    }
+
+    // Create timeline string for timestamps
+    let timestamp_line = format!(
+        "{h1:02}:{m1:02}:{s1:02},{ms1:03} --> {h2:02}:{m2:02}:{s2:02},{ms2:03}{encoded_clrf}"
+    );
+
+    // Encode and write timestamp line
+    let used = encode_line(context, buffer_slice, timestamp_line.as_bytes());
+
+    if write_wrapped(unsafe { (*context.out).fh }, &buffer_slice[..used as usize]).is_err() {
+        return 0;
+    }
+
+    // Write all 15 lines with their encoding information
+    for i in 0..15 {
+        let subline_slice = unsafe {
+            std::slice::from_raw_parts_mut(context.subline, 1024) // temporary, should be inputted after encoder_ctx => EncoderCtx
+        };
+
+        type EncodeFn = fn(&encoder_ctx, &mut [c_uchar], usize, &eia608_screen) -> c_uint;
+        let steps: &[EncodeFn] = &[get_line_encoded, get_color_encoded, get_font_encoded];
+        for &encode_fn in steps {
+            let length = encode_fn(context, subline_slice, i, data);
+            if write_wrapped(
+                unsafe { (*context.out).fh },
+                &subline_slice[..length as usize],
+            )
+            .is_err()
+            {
+                return 0;
+            }
+        }
+
+        // Write CRLF
+        let crlf_slice = unsafe {
+            std::slice::from_raw_parts(
+                context.encoded_crlf.as_ptr(),
+                context.encoded_crlf_length as usize,
+            )
+        };
+
+        if write_wrapped(unsafe { (*context.out).fh }, crlf_slice).is_err() {
+            return 0;
+        }
+
+        wrote_something = 1;
+    }
+
+    // Write final CRLF
+    let crlf_slice = unsafe {
+        std::slice::from_raw_parts(
+            context.encoded_crlf.as_ptr(),
+            context.encoded_crlf_length as usize,
+        )
+    };
+
+    if write_wrapped(unsafe { (*context.out).fh }, crlf_slice).is_err() {
+        return 0;
+    }
+
+    wrote_something
+}
diff --git a/src/rust/src/encoder/mod.rs b/src/rust/src/encoder/mod.rs
new file mode 100644
index 000000000..bad056cb4
--- /dev/null
+++ b/src/rust/src/encoder/mod.rs
@@ -0,0 +1,99 @@
+use crate::bindings::{ccx_encoding_type, ccx_output_format};
+use lib_ccxr::common::OutputFormat;
+use lib_ccxr::encoder::txt_helpers::get_str_basic;
+use lib_ccxr::util::encoding::Encoding;
+use std::os::raw::{c_int, c_uchar};
+
+pub mod common;
+pub mod g608;
+pub mod simplexml;
+/// # Safety
+/// This function is unsafe because it deferences to raw pointers and performs operations on pointer slices.
+#[no_mangle]
+pub unsafe fn ccxr_get_str_basic(
+    out_buffer: *mut c_uchar,
+    in_buffer: *mut c_uchar,
+    trim_subs: c_int,
+    in_enc: ccx_encoding_type,
+    out_enc: ccx_encoding_type,
+    max_len: c_int,
+) -> c_int {
+    let trim_subs_bool = trim_subs != 0;
+    let in_encoding = match Encoding::from_ctype(in_enc) {
+        Some(enc) => enc,
+        None => return 0,
+    };
+    let out_encoding = match Encoding::from_ctype(out_enc) {
+        Some(enc) => enc,
+        None => return 0,
+    };
+    let in_buffer_slice = if in_buffer.is_null() || max_len <= 0 {
+        return 0;
+    } else {
+        std::slice::from_raw_parts(in_buffer, max_len as usize)
+    };
+    let mut out_buffer_vec = Vec::with_capacity(max_len as usize * 4); // UTF-8 can be up to 4 bytes per character
+    let result = get_str_basic(
+        &mut out_buffer_vec,
+        in_buffer_slice,
+        trim_subs_bool,
+        in_encoding,
+        out_encoding,
+        max_len,
+    );
+    if result > 0 && !out_buffer.is_null() {
+        let copy_len = std::cmp::min(result as usize, out_buffer_vec.len());
+        if copy_len > 0 {
+            std::ptr::copy_nonoverlapping(out_buffer_vec.as_ptr(), out_buffer, copy_len);
+        }
+        if copy_len < max_len as usize {
+            *out_buffer.add(copy_len) = 0;
+        }
+    } else if !out_buffer.is_null() {
+        *out_buffer = 0;
+    }
+    result
+}
+pub trait FromCType<T> {
+    // Remove after demuxer, just import from ctorust
+    /// # Safety
+    /// This function is unsafe because it uses raw pointers to get data from C types.
+    unsafe fn from_ctype(c_value: T) -> Option<Self>
+    where
+        Self: Sized;
+}
+impl FromCType<ccx_encoding_type> for Encoding {
+    // Remove after demuxer, just import from ctorust
+    unsafe fn from_ctype(encoding: ccx_encoding_type) -> Option<Self> {
+        Some(match encoding {
+            0 => Encoding::UCS2,   // CCX_ENC_UNICODE
+            1 => Encoding::Latin1, // CCX_ENC_LATIN_1
+            2 => Encoding::UTF8,   // CCX_ENC_UTF_8
+            3 => Encoding::Line21, // CCX_ENC_ASCII
+            _ => Encoding::UTF8,   // Default to UTF-8 if unknown
+        })
+    }
+}
+impl FromCType<ccx_output_format> for OutputFormat {
+    unsafe fn from_ctype(format: ccx_output_format) -> Option<Self> {
+        Some(match format {
+            ccx_output_format::CCX_OF_RAW => OutputFormat::Raw,
+            ccx_output_format::CCX_OF_SRT => OutputFormat::Srt,
+            ccx_output_format::CCX_OF_SAMI => OutputFormat::Sami,
+            ccx_output_format::CCX_OF_TRANSCRIPT => OutputFormat::Transcript,
+            ccx_output_format::CCX_OF_RCWT => OutputFormat::Rcwt,
+            ccx_output_format::CCX_OF_NULL => OutputFormat::Null,
+            ccx_output_format::CCX_OF_SMPTETT => OutputFormat::SmpteTt,
+            ccx_output_format::CCX_OF_SPUPNG => OutputFormat::SpuPng,
+            ccx_output_format::CCX_OF_DVDRAW => OutputFormat::DvdRaw,
+            ccx_output_format::CCX_OF_WEBVTT => OutputFormat::WebVtt,
+            ccx_output_format::CCX_OF_SIMPLE_XML => OutputFormat::SimpleXml,
+            ccx_output_format::CCX_OF_G608 => OutputFormat::G608,
+            ccx_output_format::CCX_OF_CURL => OutputFormat::Curl,
+            ccx_output_format::CCX_OF_SSA => OutputFormat::Ssa,
+            ccx_output_format::CCX_OF_MCC => OutputFormat::Mcc,
+            ccx_output_format::CCX_OF_SCC => OutputFormat::Scc,
+            ccx_output_format::CCX_OF_CCD => OutputFormat::Ccd,
+        })
+    }
+}
diff --git a/src/rust/src/encoder/simplexml.rs b/src/rust/src/encoder/simplexml.rs
new file mode 100644
index 000000000..cb5c9856c
--- /dev/null
+++ b/src/rust/src/encoder/simplexml.rs
@@ -0,0 +1,89 @@
+use crate::bindings::{cc_subtitle, ccx_encoding_type_CCX_ENC_ASCII, eia608_screen, encoder_ctx};
+use crate::encoder::ccxr_get_str_basic;
+use crate::encoder::common::write_raw;
+use lib_ccxr::common::CCX_DECODER_608_SCREEN_WIDTH;
+use lib_ccxr::info;
+use std::os::raw::{c_int, c_void};
+use std::ptr;
+
+pub fn write_cc_line_as_simplexml(
+    data: &mut eia608_screen,
+    context: &mut encoder_ctx,
+    line_number: usize,
+) {
+    let cap = b"<caption>";
+    let cap1 = b"</caption>";
+
+    let length = unsafe {
+        ccxr_get_str_basic(
+            // change to get_str_basic after encoder_ctx is replaced with EncoderCtx
+            context.subline,
+            data.characters[line_number].as_mut_ptr(),
+            context.trim_subs,
+            ccx_encoding_type_CCX_ENC_ASCII,
+            context.encoding,
+            CCX_DECODER_608_SCREEN_WIDTH as i32,
+        )
+    };
+
+    // Write opening caption tag
+    let _ret = unsafe { write_raw((*context.out).fh, cap.as_ptr() as *const c_void, cap.len()) };
+
+    // Write the subtitle content
+    let ret = unsafe {
+        write_raw(
+            (*context.out).fh,
+            context.subline as *const c_void,
+            length as usize,
+        )
+    };
+
+    if ret < length as isize {
+        info!("Warning:Loss of data\n");
+    }
+
+    // Write closing caption tag
+    let _ret = unsafe {
+        write_raw(
+            (*context.out).fh,
+            cap1.as_ptr() as *const c_void,
+            cap1.len(),
+        )
+    };
+
+    // Write CRLF
+    let _ret = unsafe {
+        write_raw(
+            (*context.out).fh,
+            context.encoded_crlf.as_ptr() as *const c_void,
+            context.encoded_crlf_length as usize,
+        )
+    };
+}
+
+pub fn write_cc_buffer_as_simplexml(data: &mut eia608_screen, context: &mut encoder_ctx) -> c_int {
+    let mut wrote_something = 0;
+
+    for i in 0..15 {
+        if data.row_used[i] != 0 {
+            write_cc_line_as_simplexml(data, context, i);
+            wrote_something = 1;
+        }
+    }
+
+    wrote_something
+}
+
+pub fn write_cc_bitmap_as_simplexml(sub: &mut cc_subtitle, _context: &mut encoder_ctx) -> c_int {
+    sub.nb_data = 0;
+
+    if !sub.data.is_null() {
+        unsafe {
+            let data_box = Box::from_raw(sub.data as *mut u8);
+            drop(data_box);
+        }
+        sub.data = ptr::null_mut();
+    }
+
+    0
+}
diff --git a/src/rust/src/lib.rs b/src/rust/src/lib.rs
index f69b52d3c..218ff59f6 100644
--- a/src/rust/src/lib.rs
+++ b/src/rust/src/lib.rs
@@ -16,6 +16,7 @@ pub mod bindings {
 pub mod args;
 pub mod common;
 pub mod decoder;
+pub mod encoder;
 #[cfg(feature = "hardsubx_ocr")]
 pub mod hardsubx;
 pub mod libccxr_exports;
diff --git a/src/rust/src/parser.rs b/src/rust/src/parser.rs
index c167c2a9e..98b3e56a2 100644
--- a/src/rust/src/parser.rs
+++ b/src/rust/src/parser.rs
@@ -1150,11 +1150,11 @@ impl OptionsExt for Options {
         }
 
         if args.unicode {
-            self.enc_cfg.encoding = Encoding::Ucs2;
+            self.enc_cfg.encoding = Encoding::UCS2;
         }
 
         if args.utf8 {
-            self.enc_cfg.encoding = Encoding::Utf8;
+            self.enc_cfg.encoding = Encoding::UTF8;
         }
 
         if args.latin1 {
@@ -1582,8 +1582,8 @@ impl OptionsExt for Options {
             );
         }
 
-        if self.write_format == OutputFormat::WebVtt && self.enc_cfg.encoding != Encoding::Utf8 {
-            self.enc_cfg.encoding = Encoding::Utf8;
+        if self.write_format == OutputFormat::WebVtt && self.enc_cfg.encoding != Encoding::UTF8 {
+            self.enc_cfg.encoding = Encoding::UTF8;
             println!("Note: Output format is WebVTT, forcing UTF-8");
         }
 
@@ -2037,7 +2037,7 @@ pub mod tests {
         let (options, _) = parse_args(&["--unicode", "--no-typesetting"]);
         assert!(options.notypesetting);
 
-        assert_eq!(options.enc_cfg.encoding, Encoding::Ucs2);
+        assert_eq!(options.enc_cfg.encoding, Encoding::UCS2);
     }
 
     #[test]
@@ -2045,7 +2045,7 @@ pub mod tests {
         let (options, _) = parse_args(&["--utf8", "--trim"]);
         assert!(options.enc_cfg.trim_subs);
 
-        assert_eq!(options.enc_cfg.encoding, Encoding::Utf8);
+        assert_eq!(options.enc_cfg.encoding, Encoding::UTF8);
     }
 
     #[test]