中文文档 | English

rxlsb - High Performance XLSB Library for Rust

A pure Rust implementation for reading and writing Excel XLSB (Binary) files with exceptional performance.

Features

• High Performance: 200K rows/sec write, 2.3M rows/sec read, outperforming Java jxlsb
• Zero-copy: Bytes-based architecture minimizing memory copying
• Streaming API: Batch write, paginated read, stream processing
• Template Filling: Data filling based on existing templates
• Type Safe: Rust type system guarantees, no runtime errors
• Number Formats: Percentage, currency, thousand separator, date, time, negative red
• Custom Formats: Flexible custom number format support

Performance Comparison

Quick Start

Writing XLSB Files

use rxlsb::{XlsbWriter, CellData};
use std::path::PathBuf;

let path = PathBuf::from("output.xlsb");
let mut writer = XlsbWriter::builder().path(&path).build().unwrap();

writer.write_batch("Sheet1", |row, col| {
    match col {
        0 => CellData::text(format!("Name-{}", row)),
        1 => CellData::number(row as f64),
        _ => CellData::blank(),
    }
}, 10000, 5).unwrap();

writer.close().unwrap();

Number Formats

use rxlsb::CellData;

// Percentage: 12.30%
let cell = CellData::percentage(0.123);

// Thousand separator: -1,234.56
let cell = CellData::number_with_comma(-1234.56);

// Negative red: -500.00 (displayed in red)
let cell = CellData::number_negative_red(-500.0);

// Currency: ￥1,234.56
let cell = CellData::currency(1234.56);

// Date: 5/1/2026 10:40
let cell = CellData::date_from_timestamp(1714560000);

// Time: 10:40:00
let cell = CellData::time(1714560000);

// Custom format
let cell = CellData::number_with_format(123.45, "#,##0.00");

Reading XLSB Files

use rxlsb::{XlsbReader, CellData};
use std::path::PathBuf;

let path = PathBuf::from("output.xlsb");
let mut reader = XlsbReader::builder().path(&path).build().unwrap();

// Stream read
reader.for_each_row(0, |row_idx, cells| {
    println!("Row {}: {} cells", row_idx, cells.len());
}).unwrap();

// Paginated read
let rows = reader.read_rows(0, 0, 1000).unwrap();
println!("Read {} rows", rows.len());

Installation

Add to your Cargo.toml:

[dependencies]
rxlsb = "0.2"

API Overview

CellData Types

pub enum CellData {
    Text(String),               // Text string
    Number(f64),                // Number (IEEE 754 double)
    NumberWithFormat(f64, String), // Number with custom format
    Date(DateTime<Utc>),        // Date/Time
    DateWithFormat(i64, String), // Date with format string
    Bool(bool),                 // Boolean
    Blank,                      // Empty cell
    Error(CellError),           // Error value (#DIV/0!, #VALUE!, etc.)
}

Write API

• write_batch: Batch write entire sheet, suitable for small-medium data
• start_sheet / write_rows / end_sheet: Stream write, suitable for large data

Read API

• for_each_row: Stream read row by row, suitable for large data
• read_rows: Paginated read batch data, suitable for pagination display

Architecture

• Layer 1: IO layer - BufferReader/BufferWriter (zero-copy Bytes)
• Layer 2: Container layer - ZIP container reader/writer
• Layer 3: Format layer - BIFF12 format serializer/deserializer
• Layer 4: API layer - XlsbReader/XlsbWriter/TemplateFiller

Project Status

• ✅ Core read/write functionality complete
• ✅ Template filling support
• ✅ Number format support (percentage, currency, date, time, custom)
• ✅ All tests passing
• ✅ Performance optimized (outperforming Java jxlsb)
• ✅ API documentation complete
• 🚧 Formula cells support (planned for 0.3.0)
• 🚧 Rich text cells support
• 🚧 Chart support

Related Projects

• jxlsb - Java implementation
• cxlsb - ANSI C implementation
• jsxlsb - Node.js implementation

License

MIT License

Contributing

Contributions welcome! Please read the contributing guidelines before submitting PRs.

Changelog

See CHANGELOG.md for version history.