ALEC — Adaptive Lazy Evolving Compression

A smart compression codec for bandwidth-constrained environments

Features • Use Cases • Quick Start • Documentation • Contributing

Why ALEC?

In many environments, every bit counts:

• 🛰️ Satellite communications at a few kbps
• 🌿 Battery-powered IoT sensors lasting years
• 🌍 Rural areas with limited satellite connectivity
• 🌊 Underwater acoustic links
• 🏭 Industrial networks with restricted bandwidth

ALEC addresses these challenges with an innovative approach: transmit only what has value.

Features

🦥 Lazy Compression

ALEC doesn't transmit all data — it first sends the decision, then details only if needed.

Without ALEC:  [Complete data] ──────────────────────▶ 1000 bytes
With ALEC:     [Alert: anomaly detected] ────────────▶ 12 bytes
               [Details on demand] ──────────────────▶ 500 bytes (if requested)

🔄 Evolving Context

Encoder and decoder build a shared dictionary that improves over time.

Week 1:  "temperature=22.3°C" ──────────────────────▶ 20 bytes
Week 4:  [code_7][+0.3] ───────────────────────────▶ 3 bytes

⚖️ Smart Asymmetry

Computational effort is placed where resources exist.

📊 Priority Classification

Each data point receives a priority that determines its handling:

Use Cases

🚜 Connected Agriculture

Field sensors monitor moisture, temperature, and nutrients. With ALEC, they run 10 years on battery by transmitting only alerts and anomalies.

🏥 Rural Telemedicine

A portable ultrasound in a remote area first sends "suspected cardiac anomaly" in 50 bytes. The remote doctor decides if they need the full image.

🚛 Vehicle Fleets

500 trucks report their position. After a few weeks, the system knows the usual routes and only transmits deviations.

🛰️ Space Observation

A satellite photographs Earth. It only sends significant changes compared to previous images.

➡️ See all detailed use cases

Quick Start

Prerequisites

• Rust 1.70+ (encoder and decoder)
• Or: C compiler (embedded encoder only)

Installation

# Clone the repo
git clone https://github.com/zeekmartin/alec-codec.git
cd alec-codec

# Build
cargo build --release

# Run tests
cargo test

First Example

use alec::{Encoder, Decoder, Context, RawData};

fn main() {
    // Create encoder and decoder with shared context
    let mut ctx_emitter = Context::new();
    let mut ctx_receiver = Context::new();
    
    let encoder = Encoder::new();
    let decoder = Decoder::new();
    
    // Simulate measurements
    for i in 0..100 {
        let data = RawData::new(20.0 + (i as f64 * 0.1), i);
        
        // Encode
        let message = encoder.encode(&data, &ctx_emitter);
        ctx_emitter.observe(&data);
        
        // ... transmit message ...
        
        // Decode
        let decoded = decoder.decode(&message, &ctx_receiver).unwrap();
        ctx_receiver.observe(&decoded);
        
        println!("Original: {:.1}, Size: {} bytes", 
                 data.value, message.len());
    }
}

➡️ Complete getting started guide

Documentation

Performance

Results on reference dataset (temperature sensor, 24h, 1 measurement/min):

Roadmap

• v0.1 — Functional prototype ✅
• v0.2 — Evolving context ✅
• v0.3 — Automatic synchronization ✅
• v0.4 — Fleet mode ✅
• v1.0 — Production ready ✅

➡️ See the complete roadmap

Contributing

Contributions are welcome! See:

• CONTRIBUTING.md — Contribution guide
• prompts/ — Templates for features, bugfixes, etc.
• examples/ — Example workflows

# Typical workflow
1. Fork the repo
2. Create a branch: git checkout -b feature/my-feature
3. Follow the appropriate template in prompts/
4. Submit a PR

License

ALEC is dual-licensed:

Open Source (AGPL-3.0)

Free for open source projects, research, and personal use. You must open-source your code if you distribute ALEC or use it in a network service.

[dependencies]
alec = "1.0"

Commercial License

For proprietary use without open-source obligations. Starting at $500/year for startups.

👉 Get a Commercial License

See LICENSE for details.

Acknowledgments

ALEC draws inspiration from:

• NASA error-correcting codes (turbo codes, LDPC)
• Dictionary compression (LZ77, LZ78)
• Efficient IoT protocols (CoAP, MQTT-SN)

_{Made with ❤️ for a world where every bit counts}