ExZarr v1.0.0 - First Stable Release

ExZarr v1.0.0 - First Stable Release

Release Date: January 27, 2026

We're thrilled to announce the first stable release of ExZarr - a pure Elixir implementation of the Zarr specification for compressed, chunked, N-dimensional arrays!

Why ExZarr?

ExZarr brings the power of Zarr to the Elixir ecosystem, enabling:

• High-performance scientific data storage with compression and chunking
• Full Python zarr-python compatibility for seamless interoperability
• Production-grade reliability with comprehensive testing and security
• Multiple storage backends including filesystem, S3, GCS, and more
• Parallel chunk processing for optimal performance on large datasets

Installation

def deps do
  [
    {:ex_zarr, "~> 1.0"}
  ]
end

Key Features

Core Functionality

• N-dimensional arrays with 10 data types (int8-64, uint8-64, float32/64)
• Zarr v2 and v3 support with automatic version detection
• Flexible chunking along arbitrary dimensions
• Compression using zlib, zstd, lz4, and more
• Hierarchical groups for organizing multiple arrays
• Chunk streaming with lazy evaluation and parallel processing
• Custom storage backends with plugin architecture

Performance

• 26x faster multi-chunk reads with near-optimal scaling
• Automatic parallel I/O and decompression
• Intelligent chunk caching with LRU eviction
• Zero-copy operations where possible

Storage Backends

• Memory: Fast in-memory storage for testing and temporary data
• Filesystem: Local disk storage with full v2/v3 compatibility
• Zip: Single-file archives for portability
• Cloud: S3, GCS, Azure Blob Storage (production-ready)
• Database: MongoDB GridFS, Mnesia, ETS

Production-Ready Quality

Comprehensive Testing

• 1,713 total tests (146 doctests + 65 properties + 1,502 unit tests)
• 100% passing rate (0 failures)
• 80.3% code coverage with 100% coverage on 6 critical modules
• Property-based testing with 65 properties across codecs, storage, and indexing

Code Quality

• Zero compilation warnings
• Credo Grade A+ (strict mode, 0 issues, 1,396 mods/funs analyzed)
• Dialyzer passing (all type specs validated)
• Zero documentation warnings (mix docs clean)
• Sobelow security scan (0 high/medium warnings)

Security

• Comprehensive Security Policy (SECURITY.md with 600+ lines)
• Static security analysis with Sobelow integration
• Input validation guidelines with code examples
• Path traversal prevention documentation
• Cloud authentication best practices
• Vulnerability disclosure process

Documentation

• Complete API documentation with examples for every public function
• 5 comprehensive guides:
  • Getting Started
  • Advanced Usage
  • Performance Tuning
  • Migration from Python
  • Error Handling & Telemetry
• Interoperability guide for Python zarr-python
• Security best practices guide

Test Coverage Improvements (v0.7.0 → v1.0.0)

Module	v0.7.0	v1.0.0	Improvement
format_converter.ex	20%	80%	+60pp
indexing.ex	12.1%	85.1%	+73pp
metadata.ex	59.1%	79.5%	+20pp
storage.ex	~29%	68.1%	+39pp
filesystem.ex	0%	82%	+82pp
zip.ex	66.6%	95.2%	+29pp
Overall	76.3%	80.3%	+4pp

Modules with 100% Coverage

• ex_zarr.ex
• application.ex
• chunk_cache.ex
• version.ex
• storage/backend.ex
• codecs/codec.ex

Python Interoperability

ExZarr is fully compatible with Python zarr-python. Arrays created with ExZarr can be read by Python and vice versa:

Elixir → Python

# Create array in Elixir
{:ok, array} = ExZarr.create(
  shape: {1000, 1000},
  chunks: {100, 100},
  dtype: :float64,
  storage: :filesystem,
  path: "/tmp/shared_array"
)

Python → Elixir

# Read in Python
import zarr
z = zarr.open('/tmp/shared_array', mode='r')
data = z[:]

Use Cases

Scientific Computing

• Climate data analysis
• Genomics and bioinformatics
• Medical imaging
• Astronomy and astrophysics

Machine Learning

• Large training datasets
• Model checkpoints
• Feature stores
• Distributed training data

Data Engineering

• ETL pipelines
• Data lakes
• Archive storage
• Time-series data

Performance Benchmarks

Single chunk read:     0.5ms
Multi-chunk read (10): 2.1ms (26x faster than sequential)
Compression (zlib):    1.2ms for 1MB
Parallel writes:       3.5ms for 100 chunks
Cache hit:             0.05ms

See Performance Guide for detailed benchmarks and tuning.

Security

ExZarr v1.0.0 has undergone comprehensive security analysis:

• 0 high/medium confidence vulnerabilities (Sobelow scan)
• 45 low-confidence warnings (all documented as expected behavior)
• Comprehensive security documentation with safe usage examples
• Input validation guidelines for production deployments

Breaking Changes

None. This is the first stable release, establishing the baseline API.

Migration from v0.7.0

No code changes required! Just update your dependency:

# mix.exs
{:ex_zarr, "~> 1.0"}

Then run:

mix deps.get

New Features Since v0.7.0

Testing & Quality

• 295 new tests added (56 for metadata, 69 for indexing, 39 for storage, etc.)
• 44 new property-based tests
• Test coverage increased from 76.3% to 80.3%
• Zero-warning policy enforced (compilation, credo, dialyzer, docs)

Security & Documentation

• Complete SECURITY.md with vulnerability disclosure process
• Sobelow static security analysis integration
• Enhanced error handling guide with recovery patterns
• Telemetry guide with instrumentation examples

Code Quality

• All public functions now have comprehensive @doc annotations
• All modules have detailed @moduledoc annotations
• Property tests expanded from 21 to 65 properties
• Comprehensive backend test suites for filesystem and zip storage

Looking Forward

Planned for v1.1.0:

• Additional cloud storage backend optimizations
• Enhanced v3 format support
• Performance improvements for large arrays (>1TB)
• Additional convenience functions for common patterns
• Extended sharding support

Resources

• Documentation: https://hexdocs.pm/ex_zarr
• GitHub: https://github.com/thanos/ExZarr
• Hex.pm: https://hex.pm/packages/ex_zarr
• Zarr Specification: https://zarr.dev
• Security Policy: See SECURITY.md in repository

Acknowledgments

Thank you to:

• The Zarr community for the excellent specification
• The Elixir community for feedback and testing
• All contributors who helped make v1.0.0 possible

Support

• Issues: https://github.com/thanos/ExZarr/issues
• Discussions: https://github.com/thanos/ExZarr/discussions
• Security: See SECURITY.md for vulnerability reporting

License

MIT License - See LICENSE file for details

---

ExZarr 0.7.0 Release Notes

ExZarr 0.7.0 Release Notes

Release date: January 26, 2026

Overview

Version 0.7.0 adds chunk streaming, custom encoding, and group management features to improve performance and usability.

Breaking Changes

None. All changes are backward compatible.

Summary of Changes

New in 0.7.0:

• Lazy chunk streaming with constant memory usage
• Parallel chunk processing with configurable concurrency
• Custom chunk key encoders via behavior pattern
• Dictionary-style group access with bracket notation
• Group hierarchy visualization with ASCII tree
• Batch creation for efficient metadata writes
• Bug fixes for dialyzer and test stability

Statistics:

• 452 new tests added (total: 1246)
• 81 new test cases across 3 new test files
• 0 failures, full backward compatibility
• All quality checks passing

Bug Fixes

• Fixed dialyzer type warnings in chunk streaming code
• Fixed cache key construction in parallel chunk operations
• Fixed group path handling for filesystem storage
• Improved test stability across different OTP versions

Performance Improvements

• Chunk streaming uses constant memory regardless of chunk count
• Parallel chunk processing with configurable concurrency
• Batch group creation reduces cloud storage latency

New Features

Chunk Streaming

Stream array chunks lazily with constant memory usage:

# Sequential streaming
array
|> Array.chunk_stream()
|> Stream.each(fn {index, data} -> process(index, data) end)
|> Stream.run()

# Parallel processing with 4 workers
array
|> Array.chunk_stream(parallel: 4)
|> Enum.to_list()

# With progress tracking
Array.chunk_stream(array,
  progress_callback: fn done, total ->
    IO.puts("#{done}/#{total}")
  end
)

Custom Chunk Key Encoding

Define custom chunk naming schemes:

defmodule MyEncoder do
  @behaviour ExZarr.ChunkKey.Encoder

  def encode(chunk_index, _opts) do
    indices = Tuple.to_list(chunk_index)
    "chunk_" <> Enum.join(indices, "_")
  end

  def decode(chunk_key, _opts) do
    # Parse "chunk_0_1_2" back to {0, 1, 2}
  end

  def pattern(_opts), do: ~r/^chunk_\d+(_\d+)*$/
end

# Register and use
ChunkKey.register_encoder(:custom, MyEncoder)
{:ok, array} = Array.create(
  shape: {100, 100},
  chunk_key_encoding: :custom
)

Group Access and Management

Access groups and arrays using path notation:

# Dictionary-style access
temperature = group["sensors/temperature"]
group["experiments/exp1/results"] = array

# Create group hierarchy
{:ok, results} = Group.require_group(root, "exp1/run2/results")

# Visualize structure
IO.puts(Group.tree(root))
# Output:
# /
# ├── [A] temperature (1000, 1000)
# └── [G] experiments
#     └── [A] results (500, 500)

# Batch create for efficiency
{:ok, created} = Group.batch_create(root, [
  {:group, "exp1"},
  {:group, "exp2"},
  {:array, "exp1/data", shape: {100}, chunks: {10}, dtype: :float32}
])

Upgrade Notes

Update your mix.exs:

{:ex_zarr, "~> 0.7.0"}

Then run:

mix deps.get

No code changes required. New features are opt-in.

Statistics

• 1246 tests (452 new tests added)
• 0 failures
• Full dialyzer compliance
• 100% backward compatible

ExZarr v0.3.0 Release

ExZarr v0.3.0 Release Notes

Release Date: January 24, 2026
Previous Version: v0.1.0
Repository: https://github.com/thanos/ex_zarr

Overview

ExZarr v0.3.0 represents a major advancement in the library's capabilities, transitioning from a core implementation to a comprehensive, production-ready Zarr v2 solution for Elixir. This release introduces:

• Native implementations of all major compression codecs via Zig NIFs (from v0.2.0)
• Custom codec plugin system with behavior-based architecture (from v0.2.0)
• CRC32C checksum codec for data integrity verification (from v0.2.0)
• Extensive storage backend support (10 backends including all major cloud providers)
• Complete filter transformation system with 6 essential filters

Major Features

Storage Backend System

This release introduces a comprehensive storage backend architecture with 10 different backends, enabling ExZarr to work seamlessly across various storage environments.

New Storage Backends

Cloud Storage Providers:

• AWS S3: Full S3 integration via ExAWS with support for:

  • Configurable regions and endpoints
  • Access key and secret key authentication
  • Bucket and prefix-based organization
  • Chunk-level operations optimized for S3 APIs

• Google Cloud Storage (GCS): Complete GCS support featuring:

  • Service account authentication via Goth
  • Project-based organization
  • Bucket and prefix management
  • Native Google Cloud API integration

• Azure Blob Storage: Azure integration including:

  • Connection string and SAS token authentication
  • Container and prefix-based storage
  • Azure-native blob operations
  • Full metadata support

• MongoDB GridFS: Distributed file storage with:

  • GridFS protocol implementation for large file storage
  • MongoDB replication support
  • Configurable bucket organization
  • Distributed database benefits

BEAM-Native Backends:

• ETS (Erlang Term Storage): High-performance in-memory storage:

  • Lightning-fast read/write operations
  • Atomic operations support
  • Native BEAM integration
  • Ideal for ephemeral data and testing

• Mnesia: Distributed database backend:

  • Replication across BEAM cluster nodes
  • RAM and disk storage options
  • ACID transaction support
  • Fault-tolerant distributed storage

Utility Backends:

• Zip Archive: Single-file archive storage:

  • All chunks and metadata in one file
  • Simplified distribution and archival
  • Full read/write support with in-memory caching
  • Erlang :zip module integration (no external dependencies)

• Mock: Testing and development backend:

  • Controllable error simulation
  • Operation tracking and verification
  • Latency simulation
  • Comprehensive testing utilities

Storage Backend Architecture

All storage backends implement a unified ExZarr.Storage.Backend behavior providing:

• Consistent CRUD operations across all backends
• Dynamic backend registration via GenServer registry
• Supervised initialization in OTP supervision tree
• Metadata management (.zarray files)
• Chunk listing and existence checking
• Error handling with standardized error tuples

Compression Codec System

Complete native implementations of all major compression algorithms via Zig NIFs, along with an extensible custom codec plugin system. All codecs from v0.2.0 are included in this release.

Native Compression Codecs

All compression codecs are implemented using high-performance native code:

Implemented Codecs:

• zlib: Erlang built-in :zlib module (gzip compression)
• zstd: Zig NIF with libzstd (Zstandard - excellent compression ratio and speed)
• lz4: Zig NIF with liblz4 (extremely fast compression/decompression)
• snappy: Zig NIF with libsnappy (optimized for speed over compression ratio)
• blosc: Zig NIF with libblosc (meta-compressor with multiple algorithms)
• bzip2: Zig NIF with libbz2 (high compression ratio)
• crc32c: Pure Zig implementation (RFC 3720 checksum codec)
• none: No compression (pass-through)

CRC32C Checksum Codec

Pure Zig implementation of RFC 3720 CRC32C for data integrity verification:

Features:

• Castagnoli polynomial (0x1EDC6F41) for superior error detection
• Table-driven algorithm for optimal performance
• 4-byte overhead per chunk (little-endian format)
• Automatic corruption detection on decompression
• Python zarr-python compatible
• Returns {:error, :checksum_mismatch} on corrupted data

Usage:

# Create array with checksum validation
{:ok, array} = ExZarr.create(
  shape: {1000, 1000},
  chunks: {100, 100},
  dtype: :float64,
  compressor: :crc32c
)

Custom Codec Plugin System

Extensible architecture enabling user-defined compression and transformation codecs:

Architecture Components:

• ExZarr.Codecs.Codec behavior defining the codec contract
• ExZarr.Codecs.Registry GenServer for runtime codec management
• OTP supervision tree integration for fault tolerance
• ETS-backed storage for fast codec lookups
• Dynamic registration and unregistration support

Codec Behavior Contract:

defmodule MyCustomCodec do
  @behaviour ExZarr.Codecs.Codec

  @impl true
  def codec_id, do: :my_codec

  @impl true
  def codec_info do
    %{
      name: "My Custom Codec",
      version: "1.0.0",
      type: :compression,
      description: "Custom compression algorithm"
    }
  end

  @impl true
  def available?, do: true

  @impl true
  def encode(data, opts) do
    # Compression logic
    {:ok, compressed_data}
  end

  @impl true
  def decode(data, opts) do
    # Decompression logic
    {:ok, decompressed_data}
  end

  @impl true
  def validate_config(opts), do: :ok
end

Registration and Usage:

# Register custom codec
:ok = ExZarr.Codecs.Registry.register(MyCustomCodec)

# Use in array creation
{:ok, array} = ExZarr.create(
  shape: {1000, 1000},
  chunks: {100, 100},
  dtype: :float64,
  compressor: :my_codec
)

# Unregister when no longer needed
:ok = ExZarr.Codecs.Registry.unregister(:my_codec)

Capabilities:

• Compression codecs (standard data compression)
• Transformation codecs (data transformations)
• Checksum codecs (data integrity verification)
• Filter codecs (pre-compression transformations)
• Full integration with built-in codecs
• Query codec information and availability

Filter Transformation System

A complete implementation of Zarr v2 filter pipelines for data transformation before compression.

Implemented Filters

Essential Lossless Filters:

• Delta Filter: Difference encoding for sequential data

  • Configurable data types (dtype and astype)
  • Overflow handling considerations
  • Compatible with Python numcodecs.Delta

• Shuffle Filter: Byte shuffling for improved compression ratios

  • Configurable element size
  • Bit-level operations for optimal compression
  • Compatible with Python numcodecs.Shuffle

• AsType Filter: Type conversion between data types

  • Lossless conversions where precision allows
  • Scale-based conversions for precision reduction
  • Configurable decode data type

Lossy Transformation Filters:

• Quantize Filter: Precision reduction for floating-point data

  • Configurable decimal digit precision
  • Mantissa bit reduction
  • Suitable for lossy compression scenarios

• FixedScaleOffset Filter: HDF5-compatible scale/offset transformations

  • Linear scaling with offset
  • Integer quantization of floating-point data
  • Compatible with HDF5 scale/offset filters

• BitRound Filter: Mantissa bit reduction (simplified implementation)

  • Configurable mantissa bits to keep
  • Lossy compression for floating-point data
  • Reduces entropy for better compression

Filter Pipeline Features

• Execution Order: Filters execute in forward order during encoding, reverse order during decoding
• Multiple Filter Chaining: Support for arbitrary filter combinations
• Full Metadata Serialization: Filters stored in JSON .zarray metadata
• Python Interoperability: Compatible with Python zarr-python filter specifications
• Custom Filter Support: Behavior-based plugin system for user-defined filters
• Error Propagation: Proper error handling throughout the pipeline

Custom Plugin Systems

Custom Codec System

Extended codec architecture supporting user-defined compression algorithms:

• ExZarr.Codecs.Codec behavior for consistent implementation
• GenServer-based registry for dynamic registration
• Support for both compression and transformation codecs
• Runtime registration and unregistration
• Supervised registry in application supervision tree
• Validation and configuration management

Custom Storage Backend System

Plugin architecture for user-defined storage backends:

• ExZarr.Storage.Backend behavior with 8 required callbacks
• Dynamic registration via ExZarr.Storage.Registry
• Consistent error handling patterns
• Metadata and chunk management interfaces
• Integration with existing array operations

Custom Filter System

Extensible filter framework:

• ExZarr.Codecs.Codec behavior with filter type support
• Registration in unified codec registry
• JSON serialization/deserialization support
• Configuration validation
• Seamless integration with built-in filters

Technical Implementation

Zig NIF Architecture

All native compression codecs are implemented using Zig NIFs through the Zigler library, providing optimal performance while maintaining BEAM integration.

Implementation Features:

• Automatic Memory Management: Zig NIFs use beam.allocator for proper BEAM memory integration
• Error Handling: All opera...

ExZarr v0.1.0

ExZarr v0.1.0 Release Notes

Release Date: January 23, 2026

We're excited to announce the first release of ExZarr, a pure Elixir implementation of the Zarr array storage format. ExZarr brings chunked, compressed, N-dimensional arrays to the Elixir ecosystem with full interoperability with Python's zarr library.

Overview

ExZarr v0.1.0 provides a production-ready foundation for working with large N-dimensional arrays in Elixir applications. Whether you're building data science pipelines, scientific computing tools, or distributed data processing systems, ExZarr offers efficient, memory-conscious array operations with proven compatibility with the broader Zarr ecosystem.

Key Features

Complete Array Slicing

Read and write arbitrary rectangular regions from arrays of any dimensionality:

# Create a large array
{:ok, array} = ExZarr.create(
  shape: {10_000, 10_000},
  chunks: {1_000, 1_000},
  dtype: :float64,
  storage: :filesystem,
  path: "/data/large_array"
)

# Write data to a specific region
data = generate_data(100, 100)  # 100x100 region
:ok = ExZarr.Array.set_slice(array, data,
  start: {500, 500},
  stop: {600, 600}
)

# Read a different region
{:ok, subset} = ExZarr.Array.get_slice(array,
  start: {0, 0},
  stop: {1000, 1000}
)

Only the necessary chunks are loaded into memory, making it practical to work with arrays larger than available RAM.

Robust Validation

Comprehensive input validation prevents errors before operations begin:

• Type checking: Ensures indices are tuples and data is binary
• Dimension validation: Verifies indices match array dimensionality
• Bounds checking: Prevents out-of-bounds access
• Data size validation: Confirms data matches slice dimensions
• Clear error messages: Actionable feedback for quick debugging

# Out of bounds error
{:error, {:out_of_bounds,
  "Index out of bounds in dimension 0: stop=101 exceeds shape=100"}}

# Data size mismatch
{:error, {:data_size_mismatch,
  "Data size mismatch: expected 100 elements (400 bytes), got 50 elements (200 bytes)"}}

Python Interoperability

Full bidirectional compatibility with zarr-python means you can:

• Use ExZarr in Elixir data pipelines and read results in Python
• Process Python-generated Zarr arrays with Elixir
• Mix and match tools from both ecosystems

Verified with 14 integration tests covering:

• All 10 data types
• 1D, 2D, and 3D arrays
• Compression (zlib)
• Metadata preservation
• Chunk boundary handling

Data Type Support

Full support for scientific computing data types:

Type	Description	Size
:int8	8-bit signed integer	1 byte
:int16	16-bit signed integer	2 bytes
:int32	32-bit signed integer	4 bytes
:int64	64-bit signed integer	8 bytes
:uint8	8-bit unsigned integer	1 byte
:uint16	16-bit unsigned integer	2 bytes
:uint32	32-bit unsigned integer	4 bytes
:uint64	64-bit unsigned integer	8 bytes
:float32	32-bit floating point	4 bytes
:float64	64-bit floating point	8 bytes

Compression

Built-in zlib compression reduces storage costs:

{:ok, array} = ExZarr.create(
  shape: {1000, 1000},
  chunks: {100, 100},
  dtype: :float64,
  compressor: :zlib,  # Transparent compression
  storage: :filesystem,
  path: "/data/compressed_array"
)

Compression and decompression are automatic. Fallbacks to uncompressed storage if zstd or lz4 are requested but not available.

Storage Backends

Two storage options for different use cases:

Memory Storage - Fast, non-persistent

{:ok, array} = ExZarr.create(
  shape: {100, 100},
  chunks: {10, 10},
  storage: :memory
)

Filesystem Storage - Persistent, Zarr v2 compliant

{:ok, array} = ExZarr.create(
  shape: {100, 100},
  chunks: {10, 10},
  storage: :filesystem,
  path: "/data/my_array"
)

N-Dimensional Arrays

Support for arrays of any dimensionality with optimized implementations:

• 1D arrays: Efficient linear operations
• 2D arrays: Optimized row-major layout handling
• 3D+ arrays: Generic N-dimensional support

# 1D time series
{:ok, timeseries} = ExZarr.create(shape: {1_000_000}, ...)

# 2D image
{:ok, image} = ExZarr.create(shape: {1920, 1080}, ...)

# 3D video
{:ok, video} = ExZarr.create(shape: {1000, 1920, 1080}, ...)

# 4D hyperspectral data
{:ok, hyperspectral} = ExZarr.create(shape: {100, 512, 512, 224}, ...)

Performance Characteristics

Memory Efficiency

ExZarr loads only the chunks needed for each operation:

• Reading 100x100 region from 10,000x10,000 array loads only ~1-4 chunks
• Writes update only affected chunks (read-modify-write)
• Fill values used for uninitialized regions (no storage overhead)

Compression Impact

Real-world compression ratios with zlib (level 5):

• Sparse data: 10-100x reduction
• Scientific data: 2-5x reduction
• Random data: ~1x (minimal compression)

Quality Metrics

Test Coverage

• 196 total tests
  • 35 validation tests
  • 19 slicing operation tests
  • 14 Python integration tests
  • 128+ other unit tests
• 21 property-based tests
  • Compression round-trips
  • Chunk calculations
  • Metadata preservation
  • Edge case handling
• Zero failures across entire test suite

Code Quality

• Passes Credo strict mode (zero issues)
• Comprehensive documentation with examples
• Type specifications for public APIs
• Clear separation of concerns

Documentation

Guides

• README.md - Quick start and overview
• INTEROPERABILITY.md - Python integration guide
• API Documentation - Generated with ExDoc

Examples

• examples/python_interop_demo.exs - Interactive Python compatibility demo
• Inline examples in module documentation
• Integration test examples

Test Infrastructure

• test/support/zarr_python_helper.py - Python helper for integration tests
• test/support/setup_python_tests.sh - One-command test setup
• test/support/README.md - Integration test documentation

Installation

Add ExZarr to your mix.exs:

def deps do
  [
    {:ex_zarr, "~> 0.1.0"}
  ]
end

Then run:

mix deps.get

Quick Start

# Create an array
{:ok, array} = ExZarr.create(
  shape: {1000, 1000},
  chunks: {100, 100},
  dtype: :float64,
  compressor: :zlib,
  storage: :memory
)

# Write data
data = generate_float64_data(100 * 100)
:ok = ExZarr.Array.set_slice(array, data,
  start: {0, 0},
  stop: {100, 100}
)

# Read data back
{:ok, read_data} = ExZarr.Array.get_slice(array,
  start: {0, 0},
  stop: {100, 100}
)

# Query array properties
ExZarr.Array.ndim(array)      # => 2
ExZarr.Array.size(array)      # => 1_000_000
ExZarr.Array.itemsize(array)  # => 8

Migration and Compatibility

From Python zarr

ExZarr can read arrays created by zarr-python 2.x:

# Python: Create array
import zarr
z = zarr.open('/data/array', mode='w', shape=(1000, 1000),
              chunks=(100, 100), dtype='f8')
z[:] = data

# Elixir: Read the same array
{:ok, array} = ExZarr.open(path: "/data/array")
{:ok, data} = ExZarr.Array.get_slice(array,
  start: {0, 0},
  stop: {1000, 1000}
)

Zarr v2 Specification

ExZarr implements Zarr v2 specification:

• JSON metadata format (.zarray)
• Dot-notation chunk files (0.0, 1.2, etc.)
• Little-endian byte order
• C-order (row-major) array layout

Known Limitations

v0.1.0 Constraints

• Compression: Only zlib fully supported (zstd/lz4 fallback to uncompressed)
• Zarr Version: v2 only (v3 not yet supported)
• Storage: Memory and filesystem only (no S3/cloud storage)
• Indexing: Basic slicing only (no fancy indexing or boolean masks)
• Groups: API exists but limited testing

Platform Support

• Elixir: 1.19+ required
• Erlang/OTP: 26+ recommended
• Python: 3.6+ (for integration tests only)

Future Roadmap

Planned for v0.2.0

• Native zstd and lz4 compression
• S3 storage backend
• Parallel chunk operations
• Performance optimizations

Under Consideration

• Zarr v3 support
• Advanced indexing (fancy, boolean)
• Numpy-style broadcasting
• Distributed computing integration
• Nx tensor interoperability

Breaking Changes

None (initial release).

Upgrade Guide

Not applicable (initial release).

Contributors

Special thanks to:

• The Zarr community for the specification
• zarr-python developers for the reference implementation

Resources

• Documentation: https://hexdocs.pm/ex_zarr
• Source: https://github.com/your-username/ex_zarr
• Issues: https://github.com/your-username/ex_zarr/issues
• Zarr Specification: https://zarr.dev

Getting Help

• Open an issue on GitHub
• Check the documentation and guides
• Review examples in the repository

License

MIT License - see LICENSE file for details.

---

Thank you for using ExZarr! We're excited to see what you build with it.