Zero dot three

Cargo.toml

@@ -78,6 +78,8 @@ memmap2 = "0.9.5"
 url = "2.5.4"
 criterion = { version = "0.6.0", features = ["html_reports"] }
 dashmap = "6.1.0"
+flate2 = "1.0"
+lazy_static = "1.5"
 
 [profile.release]
 strip = "symbols"           # See split-debuginfo - allows us to drop the size by ~65%

README.md

@@ -19,15 +19,7 @@
   </p>
 </p>
 
-> **⚠️ Development Notice**: We are currently in the process of releasing Rio 0.3.0, which includes major performance improvements and architectural changes. The main branch is under active development and may be unstable. For stable usage, please use [v0.2.20 or below](https://github.com/raphamorim/rio/releases).
-
-## About
-
-Documentation: https://rioterm.com
-
-If you are using or want to help in any way please consider to donate via [Github Sponsors](https://github.com/sponsors/raphamorim).
-
-Rio would not be possible without [Alacritty](https://github.com/alacritty/alacritty/), since a lot of Rio functionalities (e.g: ANSI parser, events, processor) was originally written (and still uses a good amount) of Alacritty code.
+Documentation: [rioterm.com](https://rioterm.com).
 
 ## Supporting the Project
 

copa/examples/advanced_benchmark.rs

@@ -360,7 +360,6 @@ fn detect_implementation() -> &'static str {
 
 fn print_system_info() {
     println!("Copa Parser Advanced Benchmark Suite");
-    println!("====================================");
     println!();
 
     let implementation = detect_implementation();
@@ -422,19 +421,4 @@ fn main() {
         println!();
         println!("Results exported to: {filename}");
     }
-
-    println!();
-    println!("Usage Instructions:");
-    println!("==================");
-    println!();
-    println!("To compare performance between implementations:");
-    println!("1. Run on main branch:      git checkout main && cargo run --example advanced_benchmark --release");
-    println!("2. Run on simd-utf8 branch: git checkout simd-utf8 && cargo run --example advanced_benchmark --release");
-    println!("3. Compare the generated JSON files or console output");
-    println!();
-    println!("For statistical analysis with criterion:");
-    println!("  cargo bench --bench parser_benchmark");
-    println!();
-    println!("For HTML reports:");
-    println!("  cargo bench && open target/criterion/report/index.html");
 }

copa/examples/benchmark_comparison.rs

@@ -147,8 +147,6 @@ fn run_chunked_test() -> BenchmarkResult {
 
 fn print_system_info() {
     println!("Copa Parser Performance Benchmark");
-    println!("=================================");
-    println!();
 
     // Try to detect if we're using simdutf8 or std
     let implementation =
@@ -287,19 +285,4 @@ fn main() {
             / real_world_tests.len() as f64;
         println!("  Real-world scenarios: {real_world_avg:.2} MB/s average");
     }
-
-    println!();
-    println!("Usage Instructions:");
-    println!("==================");
-    println!();
-    println!("To compare performance between implementations:");
-    println!("1. Run on main branch:     git checkout main && cargo run --example benchmark_comparison --release");
-    println!("2. Run on simd-utf8 branch: git checkout simd-utf8 && cargo run --example benchmark_comparison --release");
-    println!("3. Compare the results manually or save outputs to files for analysis");
-    println!();
-    println!("For detailed statistical analysis:");
-    println!("  cargo bench --bench parser_benchmark");
-    println!();
-    println!("For HTML reports with graphs:");
-    println!("  cargo bench --bench parser_benchmark && open target/criterion/report/index.html");
 }

copa/src/lib.rs

@@ -182,7 +182,7 @@ impl<const OSC_RAW_BUF_SIZE: usize> Parser<OSC_RAW_BUF_SIZE> {
             State::EscapeIntermediate => self.advance_esc_intermediate(performer, byte),
             State::OscString => self.advance_osc_string(performer, byte),
             State::SosString => self.advance_opaque_string(SosDispatch(performer), byte),
-            State::ApcString => self.advance_opaque_string(ApcDispatch(performer), byte),
+            State::ApcString => self.advance_apc_string(performer, byte),
             State::PmString => self.advance_opaque_string(PmDispatch(performer), byte),
             State::Ground => unreachable!(),
         }
@@ -448,6 +448,75 @@ impl<const OSC_RAW_BUF_SIZE: usize> Parser<OSC_RAW_BUF_SIZE> {
         }
     }
 
+    #[inline(always)]
+    fn advance_apc_string<P: Perform>(&mut self, performer: &mut P, byte: u8) {
+        match byte {
+            0x00..=0x06 | 0x08..=0x17 | 0x19 | 0x1C..=0x1F => (), // Ignore control bytes
+            0x07 => {
+                // Bell-terminated APC
+                self.action_apc_end(performer);
+                self.osc_raw.clear();
+                self.osc_num_params = 0;
+                self.state = State::Ground;
+            }
+            0x18 | 0x1A => {
+                // C0 termination (CAN or SUB)
+                self.action_apc_put(performer, byte);
+                self.action_apc_end(performer);
+                performer.execute(byte);
+                self.osc_raw.clear();
+                self.osc_num_params = 0;
+                self.state = State::Ground;
+            }
+            0x1B => {
+                // Start of ST termination (\x1b\)
+                self.action_apc_end(performer);
+                self.osc_raw.clear();
+                self.osc_num_params = 0;
+                self.state = State::Escape;
+            }
+            0x3B => {
+                // Semicolon separates control data from payload
+                #[cfg(not(feature = "std"))]
+                {
+                    if self.osc_raw.is_full() {
+                        return;
+                    }
+                }
+                self.action_apc_put(performer, byte);
+                self.action_osc_put_param(); // Reuse existing method to track parameter boundaries
+            }
+            0x2C => {
+                // Comma is part of the control data (separates key-value pairs)
+                // Don't create a parameter boundary
+                self.action_apc_put(performer, byte);
+            }
+            0x20..=0xFF => {
+                // Collect valid APC content (control data or payload)
+                self.action_apc_put(performer, byte);
+            }
+        }
+    }
+
+    #[inline(always)]
+    fn action_apc_put<P: Perform>(&mut self, performer: &mut P, byte: u8) {
+        #[cfg(not(feature = "std"))]
+        {
+            if self.osc_raw.is_full() {
+                return;
+            }
+        }
+        self.osc_raw.push(byte);
+        performer.apc_put(byte); // Optionally pass to apc_put for immediate processing
+    }
+
+    #[inline]
+    fn action_apc_end<P: Perform>(&self, performer: &mut P) {
+        // APCs are handled through apc_start/apc_put/apc_end hooks which properly
+        // accumulate large payloads. This function just calls apc_end() to complete the sequence.
+        performer.apc_end();
+    }
+
     #[inline(always)]
     fn advance_opaque_string<D: OpaqueDispatch>(&mut self, mut dispatcher: D, byte: u8) {
         match byte {
@@ -865,6 +934,9 @@ pub trait Perform {
     /// Dispatch an operating system command.
     fn osc_dispatch(&mut self, _params: &[&[u8]], _bell_terminated: bool) {}
 
+    /// Dispatch an application program command.
+    fn apc_dispatch(&mut self, _params: &[&[u8]], _bell_terminated: bool) {}
+
     /// A final character has arrived for a CSI sequence
     ///
     /// The `ignore` flag indicates that either more than two intermediates
@@ -962,6 +1034,7 @@ impl<P: Perform> OpaqueDispatch for SosDispatch<'_, P> {
     }
 }
 
+#[allow(dead_code)]
 struct ApcDispatch<'a, P: Perform>(&'a mut P);
 
 impl<P: Perform> OpaqueDispatch for ApcDispatch<'_, P> {
@@ -1715,6 +1788,64 @@ mod tests {
         );
     }
 
+    #[test]
+    fn parse_kitty_apc() {
+        const INPUT: &[u8] = b"\x1b_Gf=24,s=10,v=20;Zm9v\x1b\\";
+        let mut dispatcher = Dispatcher::default();
+        let mut parser = Parser::new();
+
+        parser.advance(&mut dispatcher, INPUT);
+
+        let expected = vec![
+            Sequence::OpaqueStart(OpaqueSequenceKind::Apc),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'G'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'f'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'='),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'2'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'4'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b','),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b's'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'='),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'1'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'0'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b','),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'v'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'='),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'2'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'0'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b';'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'Z'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'm'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'9'),
+            Sequence::OpaquePut(OpaqueSequenceKind::Apc, b'v'),
+            Sequence::OpaqueEnd(OpaqueSequenceKind::Apc),
+            Sequence::Esc(vec![], false, b'\\'),
+        ];
+
+        assert_eq!(dispatcher.dispatched, expected)
+    }
+
+    #[test]
+    fn parse_kitty_apc_dispatch_params() {
+        // Test that commas in control data are NOT treated as param separators
+        // Only semicolons should separate control data from payload
+        const INPUT: &[u8] = b"\x1b_Gf=32,s=10,v=20;AQIDBA==\x1b\\";
+        let mut dispatcher = Dispatcher::default();
+        let mut parser = Parser::new();
+
+        parser.advance(&mut dispatcher, INPUT);
+
+        // Verify we got an APC dispatch
+        let apc_dispatch = dispatcher
+            .dispatched
+            .iter()
+            .find(|s| matches!(s, Sequence::OpaqueEnd(OpaqueSequenceKind::Apc)));
+        assert!(apc_dispatch.is_some(), "Should have APC dispatch");
+
+        // The test in performer::handler verifies the actual param parsing
+        // Here we just ensure the sequence completes correctly
+    }
+
     #[test]
     fn apc_c0_st_terminated() {
         expect_opaque_sequence(

docs/blog/2025-12-28-version-zero-dot-three.mdx

@@ -0,0 +1,21 @@
+---
+layout: post
+title: 'Version 0.3 released'
+date: 2025-12-28 12:28
+description: 'Welcome to the new Rio Terminal experience'
+categories: windows macos linux bsd
+---
+
+I am excited to announce Rio terminal v0.3 is released.
+
+Let's break down this long-waited release in parts, also if you're not really a reading/blog person you can optionally watch this video about the release.
+
+## New rendering architecture
+
+## Native metal for MacOS
+
+tl;dr
+
+## Quake mode
+
+## Tab mode