### Specify Exact QR Code Version (Rust)

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Generates a QR code with a precisely defined version, including both Normal (1-40) and Micro QR code versions (1-4). This allows for fine-grained control over the QR code's size and data capacity. The example shows creating a specific Normal version and two different Micro versions, demonstrating their respective widths.

```rust
use qrcode::{QrCode, Version, EcLevel};

fn main() {
    // Create a specific Normal QR code version
    let normal_code = QrCode::with_version(
        b"Hello World",
        Version::Normal(5),  // 37x37 modules
        EcLevel::M
    ).unwrap();
    println!("Normal(5) width: {} modules", normal_code.width());

    // Create a Micro QR code (smaller, less data capacity)
    let micro_code = QrCode::with_version(
        b"123",
        Version::Micro(1),  // 11x11 modules, numeric only
        EcLevel::L
    ).unwrap();
    println!("Micro(1) width: {} modules", micro_code.width());

    // Micro QR version 2 supports alphanumeric
    let micro2 = QrCode::with_version(
        b"01234567",
        Version::Micro(2),  // 13x13 modules
        EcLevel::L
    ).unwrap();
    println!("Micro(2) width: {} modules", micro2.width());
}
```

--------------------------------

### Render QR Code to PNG Image using Rust

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Generates PNG image files from QR codes using the `image` crate. Supports basic grayscale, custom RGB colors, quiet zone removal, and setting minimum or maximum dimensions. Requires the `image` crate dependency.

```rust
use qrcode::QrCode;
use image::{Luma, Rgb};

fn main() {
    let code = QrCode::new(b"https://example.com").unwrap();

    // Basic grayscale rendering
    let image = code.render::<Luma<u8>>().build();
    image.save("/tmp/qrcode_basic.png").unwrap();

    // Custom colors with RGB
    let colored_image = code.render::<Rgb<u8>>()
        .dark_color(Rgb([0, 0, 128]))      // Navy blue modules
        .light_color(Rgb([255, 255, 200])) // Light yellow background
        .quiet_zone(false)                  // Remove quiet zone border
        .min_dimensions(300, 300)           // Minimum 300x300 pixels
        .build();
    colored_image.save("/tmp/qrcode_colored.png").unwrap();

    // With specific module dimensions
    let large_image = code.render::<Luma<u8>>()
        .module_dimensions(20, 20)  // Each module is 20x20 pixels
        .build();
    large_image.save("/tmp/qrcode_large.png").unwrap();

    // Maximum size constraint
    let constrained = code.render::<Luma<u8>>()
        .max_dimensions(100, 100)  // Fit within 100x100 pixels
        .build();
    constrained.save("/tmp/qrcode_small.png").unwrap();
}
```

--------------------------------

### Render QR Code to PIC Markup Language

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Generates PIC markup language output for QR codes, which can be used with technical documentation systems like groff/troff. This snippet demonstrates basic PIC rendering and saving to a file.

```rust
use qrcode::QrCode;
use qrcode::render::pic;

fn main() {
    let code = QrCode::new(b"Documentation QR").unwrap();

    // Generate PIC output
    let pic_output = code.render::<pic::Color>()
        .min_dimensions(1, 1)
        .build();

    // Save to file for use with groff/troff
    std::fs::write("/tmp/qrcode.pic", &pic_output).unwrap();

    // Preview first few lines
    for line in pic_output.lines().take(10) {
        println!("{}", line);
    }
    println!("...");
}
```

--------------------------------

### Accessing QR Code Data and Properties

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Provides methods for inspecting the structure of a QR code, including its version, error correction level, and dimensions. It also shows how to access individual modules, check their functionality, and convert the QR code data into different formats like a vector of colors or a debug string.

```rust
use qrcode::{QrCode, Version, EcLevel, Color};

fn main() {
    let code = QrCode::with_version(b"Test", Version::Normal(1), EcLevel::M).unwrap();

    // Get basic properties
    println!("Version: {:?}", code.version());
    println!("EC Level: {:?}", code.error_correction_level());
    println!("Width: {} modules", code.width());
    println!("Max errors: {}", code.max_allowed_errors());

    // Access individual modules using index
    let (x, y) = (0, 0);
    let module_color = &code[(x, y)];
    println!("Module at ({}, {}): {:?}", x, y, module_color);

    // Check if a module is functional (finder patterns, timing, etc.)
    let is_func = code.is_functional(0, 0);
    println!("Is (0,0) functional: {}", is_func);

    // Convert to colors vector
    let colors: Vec<Color> = code.to_colors();
    let dark_count = colors.iter().filter(|&c| *c == Color::Dark).count();
    let light_count = colors.iter().filter(|&c| *c == Color::Light).count();
    println!("Dark modules: {}, Light modules: {}", dark_count, light_count);

    // Debug string output
    let debug_str = code.to_debug_str('#', '.');
    println!("\nDebug output:\n{}", debug_str);

    // Consume and get colors
    let owned_colors: Vec<Color> = code.into_colors();
    println!("Total modules: {}", owned_colors.len());
}
```

--------------------------------

### Generate EPS QR Code with Custom Colors and Dimensions (Rust)

Source: https://github.com/kennytm/qrcode-rust/blob/master/README.md

This Rust code snippet demonstrates how to create a QR code and render it as an EPS image. It allows customization of the minimum dimensions and the colors for dark and light modules. The output is a string representing the EPS data.

```rust
use qrcode::render::eps;
use qrcode::{EcLevel, QrCode, Version);

fn main() {
    let code = QrCode::with_version(b"01234567", Version::Micro(2), EcLevel::L).unwrap();
    let image = code
        .render()
        .min_dimensions(200, 200)
        .dark_color(eps::Color([0.5, 0.0, 0.0]))
        .light_color(eps::Color([1.0, 1.0, 0.5]))
        .build();
    println!("{image}");
}
```

--------------------------------

### Render QR Code to Unicode (Dense 1x2) using Rust

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Generates compact Unicode output using half-block characters, fitting two vertical pixels per character. This format is useful for dark terminals when inverted. The `qrcode` crate and its `unicode::Dense1x2` renderer are utilized.

```rust
use qrcode::QrCode;
use qrcode::render::unicode::Dense1x2;

fn main() {
    let code = QrCode::new(b"Compact QR").unwrap();

    // Normal rendering (dark on light)
    let unicode_image = code.render::<Dense1x2>().build();
    println!("Normal:\n{}", unicode_image);

    // Inverted colors (light on dark) - useful for dark terminals
    let inverted = code.render::<Dense1x2>()
        .dark_color(Dense1x2::Light)
        .light_color(Dense1x2::Dark)
        .build();
    println!("\nInverted:\n{}", inverted);

    // Without quiet zone
    let compact = code.render::<Dense1x2>()
        .quiet_zone(false)
        .build();
    println!("\nNo quiet zone:\n{}", compact);
}
```

--------------------------------

### Advanced QR Code Encoding with Bits API

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Demonstrates the low-level Bits API for custom QR code data encoding. Supports ECI designators (e.g., UTF-8), FNC1 modes (e.g., GS1), and manual control over data segments (numeric, alphanumeric, byte).

```rust
use qrcode::bits::Bits;
use qrcode::{QrCode, Version, EcLevel};

fn main() {
    // Create bits with specific version
    let mut bits = Bits::new(Version::Normal(1));

    // Push ECI designator for character set (26 = UTF-8)
    bits.push_eci_designator(26).unwrap();

    // Push byte data
    bits.push_byte_data(b"UTF-8 encoded text").unwrap();

    // Finalize with terminator
    bits.push_terminator(EcLevel::L).unwrap();

    // Create QR code from bits
    let code = QrCode::with_bits(bits, EcLevel::L).unwrap();
    println!("QR code with ECI: {:?}", code.version());

    // Example with FNC1 (GS1) encoding
    let mut gs1_bits = Bits::new(Version::Normal(2));
    gs1_bits.push_fnc1_first_position().unwrap();
    gs1_bits.push_numeric_data(b"01049123451234591597033130128").unwrap();
    gs1_bits.push_alphanumeric_data(b"%10ABC123").unwrap();
    gs1_bits.push_terminator(EcLevel::M).unwrap();
    let gs1_code = QrCode::with_bits(gs1_bits, EcLevel::M).unwrap();
    println!("GS1 QR code: {:?}", gs1_code.version());

    // Manual data mode encoding
    let mut manual_bits = Bits::new(Version::Normal(1));
    manual_bits.push_numeric_data(b"12345").unwrap();      // Numeric mode
    manual_bits.push_alphanumeric_data(b"ABC").unwrap();   // Alphanumeric mode
    manual_bits.push_byte_data(b"\x00\xff").unwrap();      // Byte mode
    manual_bits.push_terminator(EcLevel::Q).unwrap();
    let manual_code = QrCode::with_bits(manual_bits, EcLevel::Q).unwrap();
    println!("Manual encoding: {:?}", manual_code.version());
}
```

--------------------------------

### Create QR Code with Default Settings (Rust)

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Generates a new QR code from binary data using the default medium error correction level (EcLevel::M) and automatically selects the smallest QR code version capable of holding the data. It allows access to properties like version, error correction level, and width, and can convert the QR code to a vector of colors for custom processing.

```rust
use qrcode::QrCode;

fn main() {
    // Encode data into a QR code
    let code = QrCode::new(b"Hello, World!").unwrap();

    // Access QR code properties
    println!("Version: {:?}", code.version());
    println!("Error correction: {:?}", code.error_correction_level());
    println!("Width: {} modules", code.width());
    println!("Max allowed errors: {}", code.max_allowed_errors());

    // Convert to colors vector for custom processing
    let colors = code.to_colors();
    println!("Total modules: {}", colors.len());
}
```

--------------------------------

### Render QR Code to EPS Vector Graphics

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Generates Encapsulated PostScript (EPS) vector graphics from QR codes. Supports basic rendering, custom colors, and micro QR codes. The output is suitable for print and publishing workflows.

```rust
use qrcode::{QrCode, Version, EcLevel};
use qrcode::render::eps;

fn main() {
    let code = QrCode::new(b"Print-ready QR").unwrap();

    // Basic EPS rendering
    let eps_basic = code.render::<eps::Color>().build();
    std::fs::write("/tmp/qrcode.eps", &eps_basic).unwrap();

    // Custom RGB colors (values from 0.0 to 1.0)
    let eps_colored = code.render()
        .dark_color(eps::Color([0.0, 0.2, 0.4]))   // Dark blue
        .light_color(eps::Color([1.0, 0.98, 0.9])) // Off-white
        .min_dimensions(200, 200)
        .build();
    std::fs::write("/tmp/qrcode_colored.eps", &eps_colored).unwrap();

    // Micro QR code
    let micro = QrCode::with_version(b"01234567", Version::Micro(2), EcLevel::L).unwrap();
    let micro_eps = micro.render()
        .min_dimensions(200, 200)
        .dark_color(eps::Color([0.5, 0.0, 0.0]))
        .light_color(eps::Color([1.0, 1.0, 0.5]))
        .build();
    std::fs::write("/tmp/micro_qr.eps", &micro_eps).unwrap();

    println!("EPS files generated!");
}
```

--------------------------------

### Generate QR code as PIC markup in Rust

Source: https://github.com/kennytm/qrcode-rust/blob/master/README.md

This Rust code snippet demonstrates encoding data into a QR code and rendering it as PIC markup language. It allows setting minimum dimensions and uses default colors for rendering.

```rust
use qrcode::render::pic;
use qrcode::QrCode;

fn main() {
    let code = QrCode::new(b"01234567").unwrap();
    let image = code
        .render::<pic::Color>()
        .min_dimensions(1, 1)
        .build();
    println!("{image}");
}

```

--------------------------------

### Rust QR Code Error Handling

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Demonstrates how to handle various errors that can occur during QR code generation, such as data being too long for the specified version, invalid version/EC level combinations, unsupported character sets, and invalid ECI designators. It also shows a fallback pattern for selecting an error correction level.

```rust
use qrcode::{QrCode, Version, EcLevel};
use qrcode::types::QrError;

fn main() {
    // Data too long for version
    let result = QrCode::with_version(
        b"This string is too long for Micro QR version 1",
        Version::Micro(1),
        EcLevel::L
    );
    match result {
        Ok(_) => println!("Success"),
        Err(QrError::DataTooLong) => println!("Error: Data too long for this version"),
        Err(QrError::InvalidVersion) => println!("Error: Invalid version/EC combination"),
        Err(QrError::UnsupportedCharacterSet) => println!("Error: Unsupported characters"),
        Err(QrError::InvalidEciDesignator) => println!("Error: Invalid ECI designator"),
        Err(QrError::InvalidCharacter) => println!("Error: Invalid character in data"),
    }

    // Invalid version/EC level combination (Micro(1) only supports L)
    let invalid_ec = QrCode::with_version(b"123", Version::Micro(1), EcLevel::H);
    assert!(invalid_ec.is_err());
    println!("Micro(1) with H EC: {:?}", invalid_ec.err());

    // Auto-encoding with too much data
    let huge_data = vec![b'A'; 10000];
    match QrCode::with_error_correction_level(&huge_data, EcLevel::H) {
        Ok(code) => println!("Created version {:?}", code.version()),
        Err(e) => println!("Failed to create QR code: {}", e),
    }

    // Successful fallback pattern
    fn create_qr(data: &[u8]) -> Result<QrCode, QrError> {
        // Try high error correction first, fall back to lower levels
        QrCode::with_error_correction_level(data, EcLevel::H)
            .or_else(|_| QrCode::with_error_correction_level(data, EcLevel::Q))
            .or_else(|_| QrCode::with_error_correction_level(data, EcLevel::M))
            .or_else(|_| QrCode::with_error_correction_level(data, EcLevel::L))
    }

    let code = create_qr(b"Fallback example").unwrap();
    println!("Created with EC: {:?}", code.error_correction_level());
}

```

--------------------------------

### Cargo.toml QR Code Crate Configuration

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Illustrates different ways to configure the qrcode crate in Cargo.toml, including enabling default features, disabling them to use specific features like 'std' or 'svg', and combining multiple features for various output formats.

```toml
# Full features (default)
[dependencies]
qrcode = "0.14.1"

# Minimal - no image generation
[dependencies]
qrcode = { version = "0.14.1", default-features = false, features = ["std"] }

# Specific features only
[dependencies]
qrcode = { version = "0.14.1", default-features = false, features = ["std", "svg"] }

# All vector formats without image crate
[dependencies]
qrcode = { version = "0.14.1", default-features = false, features = ["std", "svg", "eps", "pic"] }

# Available features:
# - std: Standard library support (required for most features)
# - image: PNG/image generation via image crate (default)
# - svg: SVG vector output
# - eps: EPS PostScript output
# - pic: PIC markup output
# - bench: Benchmarking support (unstable)

```

--------------------------------

### Render QR Code to SVG using Rust

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Generates Scalable Vector Graphics (SVG) as a string, suitable for web applications. Supports basic rendering, custom module and background colors, and rendering micro QR codes. Requires the `qrcode` crate with SVG rendering enabled.

```rust
use qrcode::{QrCode, Version, EcLevel};
use qrcode::render::svg;

fn main() {
    let code = QrCode::new(b"https://rust-lang.org").unwrap();

    // Basic SVG rendering
    let svg_basic = code.render::<svg::Color>().build();
    std::fs::write("/tmp/qrcode.svg", &svg_basic).unwrap();

    // Custom colors
    let svg_colored = code.render()
        .dark_color(svg::Color("#2a9d8f"))   // Teal modules
        .light_color(svg::Color("#e9c46a"))  // Gold background
        .min_dimensions(200, 200)
        .build();
    std::fs::write("/tmp/qrcode_colored.svg", &svg_colored).unwrap();

    // Micro QR code as SVG
    let micro = QrCode::with_version(b"01234567", Version::Micro(2), EcLevel::L).unwrap();
    let micro_svg = micro.render()
        .min_dimensions(150, 150)
        .dark_color(svg::Color("#800000"))  // Dark red
        .light_color(svg::Color("#ffff80")) // Light yellow
        .build();
    std::fs::write("/tmp/micro_qr.svg", &micro_svg).unwrap();

    println!("SVG files generated!");
}
```

--------------------------------

### Generate QR code as a PNG image in Rust

Source: https://github.com/kennytm/qrcode-rust/blob/master/README.md

This Rust code snippet demonstrates how to encode data into a QR code and render it as a PNG image using the 'qrcode' and 'image' crates. It takes byte data as input and outputs a file at '/tmp/qrcode.png'.

```rust
use qrcode::QrCode;
use image::Luma;

fn main() {
    // Encode some data into bits.
    let code = QrCode::new(b"01234567").unwrap();

    // Render the bits into an image.
    let image = code.render::<Luma<u8>>().build();

    // Save the image.
    image.save("/tmp/qrcode.png").unwrap();
}

```

--------------------------------

### Render QR Code to String (ASCII Art) using Rust

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Generates a string representation of the QR code for terminal display. Supports default block characters, custom characters, string slices for multi-character modules, and ANSI terminal colors. The `qrcode` crate is used for generation.

```rust
use qrcode::QrCode;

fn main() {
    let code = QrCode::new(b"Hello").unwrap();

    // Default rendering with block characters
    let default_string = code.render::<char>().build();
    println!("Default:\n{}", default_string);

    // Custom characters
    let custom_string = code.render::<char>()
        .dark_color('#')
        .light_color('.')
        .quiet_zone(false)        // No border
        .module_dimensions(2, 1)  // 2 chars wide, 1 char tall per module
        .build();
    println!("\nCustom characters:\n{}", custom_string);

    // Using string slices for multi-character modules
    let block_string = code.render()
        .dark_color("██")
        .light_color("  ")
        .build();
    println!("\nBlock style:\n{}", block_string);

    // ANSI terminal colors
    let terminal = code.render()
        .dark_color("\x1b[40m  \x1b[0m")   // Black background
        .light_color("\x1b[47m  \x1b[0m")  // White background
        .build();
    println!("\nTerminal colors:\n{}", terminal);
}
```

--------------------------------

### Generate QR code as a string in Rust

Source: https://github.com/kennytm/qrcode-rust/blob/master/README.md

This Rust code snippet shows how to encode a string into a QR code and render it as a text-based representation. It allows customization of dark and light module colors, quiet zone, and module dimensions.

```rust
use qrcode::QrCode;

fn main() {
    let code = QrCode::new(b"Hello").unwrap();
    let string = code.render::<char>()
        .dark_color('#')
        .quiet_zone(false)
        .module_dimensions(2, 1)
        .build();
    println!("{string}");
}

```

--------------------------------

### Generate Micro QR code as SVG in Rust

Source: https://github.com/kennytm/qrcode-rust/blob/master/README.md

This Rust code snippet demonstrates generating a Micro QR code with specific version and error correction level, then rendering it as an SVG string. It allows customization of minimum dimensions and colors for dark and light modules.

```rust
use qrcode::{QrCode, Version, EcLevel};
use qrcode::render::svg;

fn main() {
    let code = QrCode::with_version(b"01234567", Version::Micro(2), EcLevel::L).unwrap();
    let image = code.render()
        .min_dimensions(200, 200)
        .dark_color(svg::Color("#800000"))
        .light_color(svg::Color("#ffff80"))
        .build();
    println!("{image}");
}

```

--------------------------------

### Add qrcode dependency to Cargo.toml

Source: https://github.com/kennytm/qrcode-rust/blob/master/README.md

This snippet shows how to add the 'qrcode' crate as a dependency in a Rust project's Cargo.toml file. It specifies version '0.14.1' as the default.

```toml
[dependencies]
qrcode = "0.14.1"

```

--------------------------------

### Generate QR code as Unicode string in Rust

Source: https://github.com/kennytm/qrcode-rust/blob/master/README.md

This Rust code snippet shows how to encode a string into a QR code and render it using Unicode block characters for a denser representation. It allows specifying different Unicode rendering modes and custom colors.

```rust
use qrcode::QrCode;
use qrcode::render::unicode;

fn main() {
    let code = QrCode::new("mow mow").unwrap();
    let image = code.render::<unicode::Dense1x2>()
        .dark_color(unicode::Dense1x2::Light)
        .light_color(unicode::Dense1x2::Dark)
        .build();
    println!("{image}");
}

```

--------------------------------

### Add qrcode dependency without default features in Cargo.toml

Source: https://github.com/kennytm/qrcode-rust/blob/master/README.md

This snippet demonstrates how to add the 'qrcode' crate to Cargo.toml while disabling default features and explicitly enabling the 'std' feature. This is useful if image generation capabilities are not needed.

```toml
[dependencies]
qrcode = { version = "0.14.1", default-features = false, features = ["std"] }

```

--------------------------------

### Specify Error Correction Level for QR Code (Rust)

Source: https://context7.com/kennytm/qrcode-rust/llms.txt

Creates a QR code while allowing the user to specify the error correction level. Higher error correction levels (L, M, Q, H) provide greater resilience to damage but result in larger QR codes. This function demonstrates creating QR codes with different levels and printing their versions and widths.

```rust
use qrcode::{QrCode, EcLevel};

fn main() {
    // EcLevel::L - 7% recovery (smallest code)
    let code_l = QrCode::with_error_correction_level(b"Data", EcLevel::L).unwrap();
    println!("Low EC version: {:?}, width: {}", code_l.version(), code_l.width());

    // EcLevel::M - 15% recovery (default)
    let code_m = QrCode::with_error_correction_level(b"Data", EcLevel::M).unwrap();
    println!("Medium EC version: {:?}, width: {}", code_m.version(), code_m.width());

    // EcLevel::Q - 25% recovery
    let code_q = QrCode::with_error_correction_level(b"Data", EcLevel::Q).unwrap();
    println!("Quartile EC version: {:?}, width: {}", code_q.version(), code_q.width());

    // EcLevel::H - 30% recovery (largest code, most resilient)
    let code_h = QrCode::with_error_correction_level(b"Data", EcLevel::H).unwrap();
    println!("High EC version: {:?}, width: {}", code_h.version(), code_h.width());
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.