# How EFQRCode Handles Different Error Correction Levels: A Complete Guide

> Explore how EFQRCode manages QR code error correction levels L M Q and H With EFCorrectionLevel you can balance data capacity and damage recovery for robust QR code generation.

- Repository: [EFPrefix/efqrcode](https://github.com/efprefix/efqrcode)
- Tags: deep-dive
- Published: 2026-03-01

---

**EFQRCode handles four standard QR code error correction levels (L, M, Q, H) by mapping them through the `EFCorrectionLevel` enum to the underlying `QRCodeSwift` engine, allowing developers to balance data capacity against damage recovery when generating codes.**

The `efprefix/efqrcode` repository provides a Swift wrapper around QR code generation, with error correction being a critical configuration that determines how much physical damage a printed or displayed code can sustain while remaining readable. Understanding how EFQRCode implements these levels helps developers optimize their QR codes for different environmental conditions and data densities.

## Understanding EFQRCode Error Correction Levels

### The Four Standard Levels

EFQRCode implements the ISO/IEC 18004 standard for QR codes through the `EFCorrectionLevel` enum defined in [`Source/Type/EFCorrectionLevel.swift`](https://github.com/efprefix/efqrcode/blob/main/Source/Type/EFCorrectionLevel.swift). The library supports four distinct recovery capacities:

- **Level L (Low)** – Approximately 7% of codewords can be restored
- **Level M (Medium)** – Approximately 15% of codewords can be restored  
- **Level Q (Quartile)** – Approximately 25% of codewords can be restored
- **Level H (High)** – Approximately 30% of codewords can be restored

Higher levels increase redundancy but reduce the maximum amount of data that can be encoded in a fixed-size QR code.

### Source Code Location

The error correction implementation resides primarily in two files:

- [`Source/Type/EFCorrectionLevel.swift`](https://github.com/efprefix/efqrcode/blob/main/Source/Type/EFCorrectionLevel.swift) – Defines the enum and mapping logic
- `Source/EFQRCode+Generator.swift` – Consumes the level during QR code initialization

## How EFQRCode Maps Correction Levels to the QR Engine

EFQRCode acts as a thin abstraction layer over the `QRCodeSwift` library. The `EFCorrectionLevel` enum provides a computed property `qrErrorCorrectLevel` that translates Swift-friendly enum cases into the underlying engine's expected format:

```swift
var qrErrorCorrectLevel: QRErrorCorrectLevel {
    switch self {
    case .h: return .H
    case .l: return .L
    case .m: return .M
    case .q: return .Q
    }
}

```

This mapping occurs in [`Source/Type/EFCorrectionLevel.swift`](https://github.com/efprefix/efqrcode/blob/main/Source/Type/EFCorrectionLevel.swift) and ensures that when you specify `.h` in your EFQRCode implementation, the `QRCodeSwift` engine receives the corresponding high-error-correction instruction.

## Using Error Correction Levels in EFQRCode Generator

When initializing an `EFQRCode.Generator`, you pass the desired correction level through the `errorCorrectLevel` parameter. The initializer in `Source/EFQRCode+Generator.swift` forwards this value to the underlying `QRCode` constructor:

```swift
self.qrcode = try QRCode(
    data,
    errorCorrectLevel: errorCorrectLevel.qrErrorCorrectLevel,
    withBorder: false,
    needTypeTable: true
)

```

By default, EFQRCode uses `.h` (High) if you do not specify a level, providing maximum damage tolerance at the expense of data density. You can override this default when creating generators for scenarios where storage efficiency matters more than physical resilience.

## Practical Examples

### Generate a QR Code with Default High Error Correction

The following example creates a QR code using the default high correction level, suitable for environments where the code might be partially obscured or damaged:

```swift
let generator = try EFQRCode.Generator(
    "https://example.com",
    errorCorrectLevel: .h,  // Optional – defaults to .h
    style: .basic()
)

let pngData = try generator.toPNGData(width: 300)

```

### Maximize Data Capacity with Low Error Correction

When encoding large amounts of data in a small physical space, use Level L to minimize redundancy and maximize storage:

```swift
let generator = try EFQRCode.Generator(
    "Very long text string requiring maximum storage capacity...",
    errorCorrectLevel: .l,  // Low – 7% recovery, maximum data
    style: .basic()
)

let image = try generator.toImage(width: 400)

```

### Switch Correction Levels at Runtime

You can dynamically select correction levels based on application state or user preferences:

```swift
let levels: [EFCorrectionLevel] = [.l, .m, .q, .h]

for level in levels {
    let generator = try EFQRCode.Generator(
        "Level test: \(level)",
        errorCorrectLevel: level,
        style: .basic()
    )
    let data = try generator.toPNGData(width: 250)
    // Compare output sizes or visual density
}

```

## Summary

- EFQRCode supports four standard error correction levels (L, M, Q, H) through the `EFCorrectionLevel` enum in [`Source/Type/EFCorrectionLevel.swift`](https://github.com/efprefix/efqrcode/blob/main/Source/Type/EFCorrectionLevel.swift)
- The library maps these levels to `QRCodeSwift` engine values via the `qrErrorCorrectLevel` computed property
- Default configuration uses Level H (30% recovery) unless explicitly overridden during `EFQRCode.Generator` initialization
- Higher correction levels reduce data capacity but increase physical damage tolerance, while lower levels maximize storage density
- All error correction encoding is delegated to the underlying `QRCodeSwift` library after EFQRCode performs the initial enum translation

## Frequently Asked Questions

### What is the default error correction level in EFQRCode?

EFQRCode defaults to **Level H (High)** when you create a new `Generator` instance without specifying the `errorCorrectLevel` parameter. This provides approximately 30% recovery capacity, meaning up to 30% of the QR code can be damaged or obscured while remaining readable. If you need to encode more data in a smaller space, you must explicitly specify a lower level such as `.l` or `.m`.

### How do I choose between the four error correction levels?

Select your error correction level based on the physical environment where the QR code will be displayed and the amount of data you need to encode. Use **Level L (7%)** for digital displays or clean print environments where maximum data capacity matters. Use **Level M (15%)** for standard print materials. Use **Level Q (25%)** for industrial or outdoor settings with moderate contamination risk. Use **Level H (30%)** for harsh environments, artistic QR codes with logo overlays, or situations where the code must remain readable despite significant damage.

### Does EFQRCode perform the error correction calculations itself?

No, EFQRCode delegates all error correction encoding to the underlying **QRCodeSwift** library. EFQRCode's role is limited to providing a Swift-friendly API through the `EFCorrectionLevel` enum and mapping those values to `QRCodeSwift`'s `QRErrorCorrectLevel` enum via the `qrErrorCorrectLevel` computed property. The actual Reed-Solomon error correction algorithms and redundancy calculations occur within the `QRCodeSwift` dependency, not in EFQRCode's own source files.