A single emoji such as the flag 🇺🇸 is 8 bytes and 2 codepoints, yet a reader sees one character — one grapheme cluster. StringZilla draws every one of these boundaries: sz_utf8_runes (Utf8View) walks codepoints, while sz_utf8_graphemes (Utf8Graphemes) walks user-perceived clusters. The StringZillableUnary trait turns any AsRef<[u8]> into a broad family of lazy UTF-8 iterators and views, each yielding borrowed byte sub-slices or chars on demand:

fn sz_utf8_runes(&self) -> Utf8View<'_>;                         // codepoints / random codepoint access
fn sz_utf8_split_newlines(&self) -> Utf8SplitNewlines<'_>;       // content BETWEEN hard newlines (CRLF = one)
fn sz_utf8_newlines(&self) -> Utf8Newlines<'_>;                  // the newline runs themselves
fn sz_utf8_split_whitespaces(&self) -> Utf8SplitWhitespaces<'_>; // content BETWEEN Unicode whitespace
fn sz_utf8_whitespaces(&self) -> Utf8Whitespaces<'_>;            // the whitespace runs themselves
fn sz_utf8_split_delimiters(&self) -> Utf8SplitDelimiters<'_>;   // content BETWEEN whitespace/punctuation
fn sz_utf8_delimiters(&self) -> Utf8Delimiters<'_>;              // the delimiter runs themselves
fn sz_utf8_wordbreaks(&self) -> Utf8Wordbreaks<'_>;              // all UAX-29 word segments (tiling)
fn sz_utf8_graphemes(&self) -> Utf8Graphemes<'_>;                // UAX-29 grapheme clusters
fn sz_utf8_sentences(&self) -> Utf8Sentences<'_>;                // UAX-29 sentences
fn sz_utf8_linebreaks(&self) -> Utf8Linebreaks<'_>;              // UAX-14 line-break opportunities

The naming follows one rule: the bare name (newlines/whitespaces/delimiters) yields the separators the kernel finds, while split_* yields the content between them. Chain .with_separators() on a split_* iterator to interleave both losslessly.

Every member of this family is lazy and zero-copy. Utf8View, Utf8Runes, Utf8SplitNewlines, Utf8SplitWhitespaces, Utf8Wordbreaks, Utf8Graphemes, Utf8Sentences, and Utf8Linebreaks, together with the sz_splits / sz_rsplits iterators, all borrow from the source string and yield &[u8] or &str slices on demand without allocating. There is no backing vector and no per-element heap buffer. Contrast this with the standard library, where collecting into a Vec<String> allocates the vector and a fresh heap buffer for every element, and even a Vec<&str> allocates the backing vector up front. Because these iterators borrow from the input, you can stream over millions of words or grapheme clusters of a large document with effectively zero per-element allocation, and the borrow lifetimes keep the yielded slices zero-copy.

Utf8View offers O(1) construction, len() counting the codepoints on demand, offset_of(n) for the byte offset of the Nth codepoint, and iter() for batched char iteration:

use stringzilla::StringZillableUnary;

let view = "Hello🌍".sz_utf8_runes();
assert_eq!(view.len(), 6);
assert_eq!(view.offset_of(5), Some(5));
let chars: Vec<char> = view.iter().collect();
assert_eq!(chars, vec!['H', 'e', 'l', 'l', 'o', '🌍']);

The boundary iterators wordbreaks, graphemes, sentences, and linebreaks tile the input — every byte belongs to exactly one segment, so consecutive segments are contiguous and no empty slices appear:

use stringzilla::StringZillableUnary;

let words: Vec<&[u8]> = b"Hi, world".sz_utf8_wordbreaks().collect();
assert_eq!(words, vec![&b"Hi"[..], &b","[..], &b" "[..], &b"world"[..]]);

let sentences: Vec<&[u8]> = b"Hi. Bye.".sz_utf8_sentences().collect();
assert_eq!(sentences, vec![&b"Hi. "[..], &b"Bye."[..]]);

split_newlines splits on the 8 Unicode hard newlines, treating CRLF as a single delimiter and excluding the newline from each segment, while split_whitespaces splits on the 25 Unicode whitespace characters and keeps empty segments by default; chain .skip_empty() for str::split_whitespace-style behavior:

use stringzilla::StringZillableUnary;

let lines: Vec<&str> = "Hello\nWorld\r\nRust"
    .sz_utf8_split_newlines()
    .map(|l| std::str::from_utf8(l).unwrap())
    .collect();
assert_eq!(lines, vec!["Hello", "World", "Rust"]);

let tokens: Vec<&[u8]> = b"  hi  ".sz_utf8_split_whitespaces().skip_empty().collect();
assert_eq!(tokens, vec![&b"hi"[..]]);

Every iterator is also constructible directly, for example Utf8Wordbreaks::new(text). Each exposes a STEPS const-generic batch-size knob via with_steps, written with a turbofish such as Utf8Runes::<256>::with_steps(bytes), that trades buffer size for FFI-call amortization without changing the yielded results. The default batch size is the public constant ITERATORS_DEFAULT_STEPS = 64.

§ Low Level Decoding

utf8_decode unpacks UTF-8 bytes into a UTF-32 runes buffer, returning how many bytes were consumed and codepoints written.

pub fn utf8_decode(text: &[u8], runes: &mut [u32]) -> (usize, usize); // (bytes_consumed, runes_count)

utf8_decode decodes UTF-8 into UTF-32 codepoints, filling the output buffer or draining the input per call. For inputs larger than the buffer, loop and resume at bytes_consumed. It is total: ill-formed bytes decode to U+FFFD, so every value written is a valid Unicode scalar. The end of text is the end of the input, so a truncated final sequence also decodes to one U+FFFD and is consumed; cut a streamed input into chunks at rune boundaries:

use stringzilla as sz;

let mut runes = [0u32; 16];
assert_eq!(sz::utf8_decode(b"a\xE2\x82", &mut runes), (3, 2));
assert_eq!(&runes[..2], &['a' as u32, 0xFFFD]);
let (bytes, count) = sz::utf8_decode("Hello".as_bytes(), &mut runes);
assert_eq!((bytes, count), (5, 5));
assert_eq!(runes[0], 'H' as u32);