diff --git a/.claude/scripts/implement-all-issues.sh b/.claude/scripts/implement-all-issues.sh
new file mode 100755
index 00000000..4f267c91
--- /dev/null
+++ b/.claude/scripts/implement-all-issues.sh
@@ -0,0 +1,597 @@
+#!/usr/bin/env bash
+#
+# implement-all-issues.sh
+# Two-phase workflow:
+#   1. Planning: LLM analyzes issues and creates implementation order
+#   2. Execution: Loop through plan, invoke /implement-issue for each
+#
+# This script is an ORCHESTRATOR only. Quality checks (PR review, coverage,
+# Greptile, CI validation) are handled by /implement-issue command.
+#
+
+set -euo pipefail
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+PLAN_FILE="${PLAN_FILE:-$HOME/.claude/implementation-plan.json}"
+STATE_FILE="${STATE_FILE:-$HOME/.claude/implementation-state.json}"
+MAX_ISSUES="${MAX_ISSUES:-}"           # Empty = unlimited
+LABEL_FILTER="${LABEL_FILTER:-}"       # Only process issues with this label
+ASSIGNEE_FILTER="${ASSIGNEE_FILTER:-}" # Only issues for this assignee ("none" = unassigned)
+ITERATION_DELAY="${ITERATION_DELAY:-5}" # Seconds between issues
+
+# ============================================================================
+# LOGGING
+# ============================================================================
+
+LOG_COLOR="\033[0;32m"
+WARN_COLOR="\033[0;33m"
+ERROR_COLOR="\033[0;31m"
+RESET_COLOR="\033[0m"
+
+log() { echo -e "${LOG_COLOR}[INFO]${RESET_COLOR} $*"; }
+log_warn() { echo -e "${WARN_COLOR}[WARN]${RESET_COLOR} $*"; }
+log_error() { echo -e "${ERROR_COLOR}[ERROR]${RESET_COLOR} $*"; }
+log_sep() { echo "─────────────────────────────────────────────────────────"; }
+
+# ============================================================================
+# USAGE
+# ============================================================================
+
+usage() {
+    cat <<'EOF'
+Usage: implement-all-issues.sh [OPTIONS]
+
+Two-phase orchestrator for implementing GitHub issues.
+Quality checks (PR review, coverage, Greptile, CI) are handled by /implement-issue.
+
+PHASE 1 - Planning: LLM analyzes issues and creates implementation order
+PHASE 2 - Execution: Execute each issue using /implement-issue command
+
+OPTIONS:
+    --repo <owner/name>     Repository (default: auto-detect from git origin)
+    --label <label>         Only process issues with this label
+    --assignee <username>   Only process issues for this assignee (use "none" for unassigned)
+    --max-issues <n>        Stop after N issues (default: unlimited)
+    --delay <seconds>       Delay between issues (default: 5)
+    --plan-only             Only create plan, don't execute
+    --execute-only          Skip planning, use existing plan file
+    --fresh-plan            Ignore existing plan, create new one
+    -h, --help              Show this help
+
+ENVIRONMENT VARIABLES:
+    PLAN_FILE               Where to store plan (default: ~/.claude/implementation-plan.json)
+    STATE_FILE              Where to store state (default: ~/.claude/implementation-state.json)
+    MAX_ISSUES              Maximum issues to process
+    LABEL_FILTER            Label filter
+    ASSIGNEE_FILTER         Assignee filter
+    ITERATION_DELAY         Seconds between iterations
+
+EXAMPLES:
+    # Full workflow (plan + execute)
+    implement-all-issues.sh
+
+    # Create plan first, review it, then execute
+    implement-all-issues.sh --plan-only
+    # Review ~/.claude/implementation-plan.json
+    implement-all-issues.sh --execute-only
+
+    # Create fresh plan (ignore existing)
+    implement-all-issues.sh --fresh-plan
+
+    # Specific repo with filters
+    implement-all-issues.sh --repo archebase/strata --label priority-high
+EOF
+    exit 0
+}
+
+# ============================================================================
+# REPO DETECTION
+# ============================================================================
+
+detect_repo() {
+    if [[ -n "${REPO:-}" ]]; then
+        echo "$REPO"
+        return
+    fi
+
+    local remote_url
+    remote_url=$(git remote get-url origin 2>/dev/null || true)
+
+    if [[ -z "$remote_url" ]]; then
+        log_error "Could not detect repository. Use --repo or set REPO env var."
+        exit 1
+    fi
+
+    # git@github.com:owner/repo.git
+    if [[ "$remote_url" =~ git@github.com:([^/]+)/(.+).git ]]; then
+        echo "${BASH_REMATCH[1]}/${BASH_REMATCH[2]}"
+        return
+    fi
+
+    # https://github.com/owner/repo.git
+    if [[ "$remote_url" =~ https://github.com/([^/]+)/(.+).?git? ]]; then
+        echo "${BASH_REMATCH[1]}/${BASH_REMATCH[2]}"
+        return
+    fi
+
+    log_error "Could not parse repo from: $remote_url"
+    exit 1
+}
+
+# ============================================================================
+# ISSUE FETCHING
+# ============================================================================
+
+fetch_issues() {
+    local repo="$1"
+    log "Fetching issues from $repo..."
+
+    gh issue list --repo "$repo" --state open --limit 500 \
+        --json number,title,body,labels,assignees,createdAt,url 2>/dev/null || {
+        log_error "Failed to fetch issues. Check 'gh auth status'."
+        exit 1
+    }
+}
+
+# ============================================================================
+# PHASE 1: PLANNING
+# ============================================================================
+
+create_plan() {
+    local repo="$1"
+    local issues_json="$2"
+
+    log_sep
+    log "PHASE 1: CREATING IMPLEMENTATION PLAN"
+    log_sep
+
+    # Create a temporary file with the issues data
+    local issues_file
+    issues_file=$(mktemp)
+    echo "$issues_json" > "$issues_file"
+
+    # Create prompt file
+    local prompt_file
+    prompt_file=$(mktemp)
+
+    cat > "$prompt_file" <<EOF
+You are a technical lead planning the implementation of GitHub issues.
+
+## Repository
+$repo
+
+## Filter Settings
+- Label filter: ${LABEL_FILTER:-none}
+- Assignee filter: ${ASSIGNEE_FILTER:-none}
+- Max issues: ${MAX_ISSUES:-unlimited}
+
+## Open Issues
+\`\`\`
+$(cat "$issues_file" | jq -r '.[] | "#\(.number): \(.title)\n  Labels: \(.labels // [] | map(.name) | join(", ") // "none")\n  Assignees: \(.assignees // [] | map(.login) | join(", ") // "none")\n  Body: \(.body // "empty" | .[0:500])\n"')
+\`\`\`
+
+## Your Task
+
+Create an implementation plan that:
+
+1. **Parses dependencies** from issue bodies. Look for:
+   - "depends on #N", "blocked by #N", "requires #N"
+   - "[depends on: #N]", "[blocked by: #N]"
+   - Task list items: "- [ ] #N"
+
+2. **Detects circular dependencies** and breaks them intelligently
+
+3. **Orders issues** by:
+   - Dependencies first (topological sort)
+   - Priority (critical > high > medium > low)
+   - Creation date (older first within same priority)
+   - Unassigned before assigned
+
+4. **Skips** issues with these labels:
+   - wontfix, blocked, on-hold, design-needed
+
+5. **Handles external dependencies** - if an issue depends on #N where #N is NOT in the processing set, skip with note
+
+## Output Format
+
+Write ONLY a valid JSON object to stdout:
+
+\`\`\`json
+{
+  "repository": "$repo",
+  "generated_at": "ISO-8601 timestamp",
+  "filters": {
+    "label": "${LABEL_FILTER:-null}",
+    "assignee": "${ASSIGNEE_FILTER:-null}",
+    "max_issues": ${MAX_ISSUES:-null}
+  },
+  "summary": {
+    "total_issues": <number of open issues>,
+    "processable": <number after filtering>,
+    "skipped": <number skipped>,
+    "skipped_reasons": {
+      "wontfix_label": <count>,
+      "external_dependency": <count>
+    }
+  },
+  "dependency_graph": {
+    "nodes": [
+      {"number": 42, "title": "...", "priority": "critical", "dependencies": []}
+    ],
+    "edges": [
+      {"from": 36, "to": 42, "reason": "#36 depends on #42"}
+    ]
+  },
+  "implementation_order": [
+    {
+      "position": 1,
+      "issue_number": 42,
+      "title": "...",
+      "priority": "critical",
+      "dependencies": [],
+      "estimated_complexity": "low|medium|high",
+      "rationale": "No dependencies, highest priority"
+    }
+  ],
+  "warnings": []
+}
+\`\`\`
+
+Output ONLY the JSON, nothing else.
+EOF
+
+    # Invoke Claude Code to create the plan
+    log "Invoking Claude Code to create implementation plan..."
+
+    if command -v claude &>/dev/null; then
+        claude < "$prompt_file" > "$PLAN_FILE" || {
+            log_error "Claude Code execution failed"
+            rm -f "$prompt_file" "$issues_file"
+            exit 1
+        }
+    else
+        log_warn "Claude CLI not found. Creating basic plan..."
+
+        # Fallback: basic plan with jq
+        jq -n \
+            --arg repo "$repo" \
+            --argjson issues "$issues_json" \
+            '{
+                repository: $repo,
+                generated_at: (now | todate),
+                filters: {label: $LABEL_FILTER, assignee: $ASSIGNEE_FILTER, max_issues: $MAX_ISSUES},
+                summary: {total_issues: ($issues | length), processable: ($issues | length), skipped: 0, skipped_reasons: {}},
+                dependency_graph: {nodes: [], edges: []},
+                implementation_order: ($issues | map({
+                    position: (.number | tostring),
+                    issue_number: .number,
+                    title: .title,
+                    priority: "medium",
+                    dependencies: [],
+                    estimated_complexity: "medium",
+                    rationale: "Basic ordering"
+                })),
+                warnings: ["Basic plan - Claude CLI not available"]
+            }' > "$PLAN_FILE"
+    fi
+
+    rm -f "$prompt_file" "$issues_file"
+
+    # Validate plan
+    if ! jq empty "$PLAN_FILE" 2>/dev/null; then
+        log_error "Generated plan is not valid JSON"
+        cat "$PLAN_FILE"
+        exit 1
+    fi
+
+    log "Plan saved to: $PLAN_FILE"
+}
+
+display_plan() {
+    if [[ ! -f "$PLAN_FILE" ]]; then
+        log_error "No plan found at $PLAN_FILE"
+        log "Run with --plan-only to create one first"
+        exit 1
+    fi
+
+    log_sep
+    log "IMPLEMENTATION PLAN"
+    log_sep
+
+    echo
+    jq -r '
+        "Repository: \(.repository)",
+        "Generated: \(.generated_at)",
+        "",
+        "Summary:",
+        "  Total issues: \(.summary.total_issues)",
+        "  Processable: \(.summary.processable)",
+        "  Skipped: \(.summary.skipped)",
+        "",
+        ((.warnings // []) | length > 0),
+        "Warnings: \(.warnings | length)",
+        ((.warnings // []) | map("  - \(.)") | join("\n"))
+    ' "$PLAN_FILE"
+
+    echo
+    log_sep
+    log "IMPLEMENTATION ORDER:"
+    log_sep
+
+    jq -r '
+        .implementation_order[] |
+        "\(.position | tostring | pad_left(3 | tostring; " ")). #\(.issue_number | tostring | pad_left(4 | tostring; " "))  \(.title)  [\(.priority)]\n   └─ deps: \(.dependencies | join(", ") // "none"), \(.estimated_complexity)"
+    ' "$PLAN_FILE"
+
+    log_sep
+    echo
+}
+
+# ============================================================================
+# STATE MANAGEMENT
+# ============================================================================
+
+load_state() {
+    if [[ -f "$STATE_FILE" ]]; then
+        cat "$STATE_FILE"
+    else
+        echo '{"completed": [], "failed": [], "current_position": 0}'
+    fi
+}
+
+save_state() {
+    local state="$1"
+    echo "$state" > "$STATE_FILE"
+}
+
+clear_state() {
+    rm -f "$STATE_FILE"
+}
+
+# ============================================================================
+# PHASE 2: EXECUTION
+# ============================================================================
+
+# Check if a PR already exists for an issue's branch
+check_existing_pr() {
+    local repo="$1"
+    local branch="$2"
+    local issue_number="$3"
+
+    local existing_pr
+    existing_pr=$(gh pr list --repo "$repo" --head "$branch" --json number,state,title,body,mergedAt --jq '.[0]' 2>/dev/null || echo "null")
+
+    if [[ "$existing_pr" == "null" ]]; then
+        echo "none"
+        return
+    fi
+
+    local pr_number pr_state pr_merged
+    pr_number=$(echo "$existing_pr" | jq -r '.number // empty')
+    pr_state=$(echo "$existing_pr" | jq -r '.state // "UNKNOWN"')
+    pr_merged=$(echo "$existing_pr" | jq -r '.mergedAt // empty')
+
+    # Case 1: PR was already merged
+    if [[ -n "$pr_merged" ]]; then
+        echo "merged:$pr_number"
+        return
+    fi
+
+    # Case 2: PR is open/closed but not merged - check if it references this issue
+    local pr_body
+    pr_body=$(echo "$existing_pr" | jq -r '.body // ""')
+
+    if echo "$pr_body" | grep -q "#$issue_number"; then
+        echo "exists:$pr_number:$pr_state"
+    else
+        echo "different:$pr_number:$pr_state"
+    fi
+}
+
+execute_plan() {
+    local repo="$1"
+
+    log_sep
+    log "PHASE 2: EXECUTING IMPLEMENTATION PLAN"
+    log_sep
+    log "Quality checks (PR review, coverage, Greptile, CI) handled by /implement-issue"
+    log_sep
+
+    if [[ ! -f "$PLAN_FILE" ]]; then
+        log_error "No plan found at $PLAN_FILE"
+        exit 1
+    fi
+
+    # Load state
+    local state
+    state=$(load_state)
+    local completed
+    completed=$(echo "$state" | jq -r '.completed[]')
+
+    # Get implementation order from plan
+    local count
+    count=$(jq '.implementation_order | length' "$PLAN_FILE")
+
+    local max_issues="${MAX_ISSUES:-999999}"
+    local processed=0
+
+    for ((i=0; i<count; i++)); do
+        [[ $processed -ge $max_issues ]] && break
+
+        local item
+        item=$(jq -c ".implementation_order[$i]" "$PLAN_FILE")
+
+        local number title
+        number=$(jq -r '.issue_number' <<< "$item")
+        title=$(jq -r '.title' <<< "$item")
+
+        # Skip if already completed
+        if echo "$completed" | grep -q "^$number$"; then
+            log "[$((i+1))/$count] #$number already completed, skipping"
+            continue
+        fi
+
+        log_sep
+        log "[$((i+1))/$count] Executing #$number: $title"
+        log_sep
+
+        # Check for existing PR before executing
+        local expected_branch="feature/issue-$number"
+        local pr_check
+        pr_check=$(check_existing_pr "$repo" "$expected_branch" "$number")
+
+        case "$pr_check" in
+            merged:*)
+                local pr_num="${pr_check#merged:}"
+                log "PR #$pr_num already merged, marking #$number as complete"
+                state=$(echo "$state" | jq --arg num "$number" '.completed += [$num | tonumber]')
+                save_state "$state"
+                continue
+                ;;
+            exists:*open*)
+                local pr_num="${pr_check#exists:}"
+                pr_num="${pr_num%:*}"
+                log "PR #$pr_num already exists and is open for #$number"
+                state=$(echo "$state" | jq --arg num "$number" '.completed += [$num | tonumber]')
+                processed=$((processed + 1))
+                log "✓ #$number marked complete (PR #$pr_num exists)"
+                save_state "$state"
+                continue
+                ;;
+            different:*)
+                local pr_num="${pr_check#different:}"
+                pr_num="${pr_num%:*}"
+                log_warn "Branch $expected_branch has PR #$pr_num for a DIFFERENT issue (combined PR)"
+                log "Updating PR #$pr_num to include #$number..."
+                if gh pr edit "$pr_num" --repo "$repo" --body "$(
+                    gh pr view "$pr_num" --repo "$repo" --json body -q '.body' 2>/dev/null
+                    echo ""
+                    echo "Closes #$number"
+                )" 2>/dev/null; then
+                    log "✓ Updated PR #$pr_num to reference #$number"
+                    state=$(echo "$state" | jq --arg num "$number" '.completed += [$num | tonumber]')
+                    processed=$((processed + 1))
+                else
+                    log_warn "Failed to update PR"
+                    state=$(echo "$state" | jq --arg num "$number" '.failed += [$num | tonumber]')
+                fi
+                save_state "$state"
+                continue
+                ;;
+        esac
+
+        # No existing PR - delegate to /implement-issue
+        if [[ -f "$HOME/.claude/commands/implement-issue.md" ]]; then
+            log "Delegating to: /implement-issue $number"
+            log "(handles: PR review, coverage, Greptile, CI, merge)"
+
+            if Skill skill "implement-issue" args "$number"; then
+                state=$(echo "$state" | jq --arg num "$number" '.completed += [$num | tonumber]')
+                processed=$((processed + 1))
+                log "✓ #$number completed"
+            else
+                state=$(echo "$state" | jq --arg num "$number" '.failed += [$num | tonumber]')
+                log_warn "✗ #$number failed"
+            fi
+
+            save_state "$state"
+        else
+            log_error "No implement-issue command found at ~/.claude/commands/"
+            exit 1
+        fi
+
+        # Delay before next
+        if [[ $i -lt $((count - 1)) ]] && [[ $processed -lt $max_issues ]]; then
+            log "Waiting ${ITERATION_DELAY}s before next issue..."
+            sleep "$ITERATION_DELAY"
+        fi
+    done
+
+    log_sep
+    log "EXECUTION COMPLETE"
+    log_sep
+    log "Processed: $processed issues"
+    log "Completed: $(echo "$state" | jq '.completed | length')"
+    log "Failed: $(echo "$state" | jq '.failed | length')"
+}
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+main() {
+    local repo=""
+    local plan_only=false
+    local execute_only=false
+    local fresh_plan=false
+
+    # Parse args
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --repo)        repo="$2"; shift 2 ;;
+            --label)       LABEL_FILTER="$2"; shift 2 ;;
+            --assignee)    ASSIGNEE_FILTER="$2"; shift 2 ;;
+            --max-issues)  MAX_ISSUES="$2"; shift 2 ;;
+            --delay)       ITERATION_DELAY="$2"; shift 2 ;;
+            --plan-only)   plan_only=true; shift ;;
+            --execute-only) execute_only=true; shift ;;
+            --fresh-plan)  fresh_plan=true; shift ;;
+            -h|--help)     usage ;;
+            *) log_error "Unknown: $1"; usage ;;
+        esac
+    done
+
+    # Detect repo
+    repo=$(detect_repo)
+    log "Repository: $repo"
+
+    # Execute only?
+    if [[ "$execute_only" == "true" ]]; then
+        display_plan
+        execute_plan "$repo"
+        exit 0
+    fi
+
+    # Fresh plan?
+    if [[ "$fresh_plan" == "true" ]]; then
+        rm -f "$PLAN_FILE"
+        clear_state
+        log "Cleared existing plan and state"
+    fi
+
+    # Check if plan exists
+    if [[ -f "$PLAN_FILE" ]] && [[ "$fresh_plan" != "true" ]]; then
+        log "Found existing plan: $PLAN_FILE"
+        log "Use --fresh-plan to regenerate"
+        display_plan
+    else
+        # Fetch issues
+        local issues_json
+        issues_json=$(fetch_issues "$repo")
+
+        local issue_count
+        issue_count=$(echo "$issues_json" | jq 'length')
+        log "Found $issue_count open issues"
+
+        # Create plan
+        create_plan "$repo" "$issues_json"
+
+        # Display plan
+        display_plan
+    fi
+
+    # Plan only?
+    if [[ "$plan_only" == "true" ]]; then
+        log "Plan-only mode - not executing"
+        log "Run again with --execute-only to implement"
+        exit 0
+    fi
+
+    # Execute
+    execute_plan "$repo"
+}
+
+main "$@"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c16710f1..2b33486b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,16 @@
 
 ### Added
 
+- Support for HDF5 version 2.0.0, including:
+  - Version detection and conditional compilation for HDF5 2.x
+  - Versioned API bindings for `H5Dread_chunk2`, `H5Tdecode2`, `H5Iregister_type2`
+  - New `H5T_COMPLEX` datatype class support in bindings
+  - Complex number predefined types (`H5T_COMPLEX_IEEE_F32LE`, etc.)
+  - bfloat16 predefined types (`H5T_FLOAT_BFLOAT16LE`, `H5T_FLOAT_BFLOAT16BE`)
+  - FP8 predefined types (`H5T_FLOAT_F8E4M3`, `H5T_FLOAT_F8E5M2`)
+  - `H5Tcomplex_create` function binding
+  - `Datatype::is_complex()` method (HDF5 2.0.0+)
+  - Comprehensive test suite for HDF5 2.0.0 features
 - Support for HDF5 version 1.14.0.
 - Support field renaming via `#[hdf5(rename = "new_name")]` helper attribute.
 - Add a `ByteReader` which implements `std::io::{Read, Seek}` for 1D `u8`
@@ -23,7 +33,7 @@
   library which is threadsafe.
 - Requesting a feature which is not compiled in the dynamic HDF5 library will
   now cause a compile time error.
-- The bundled version of HDF5 in `hdf5-src` is now 1.14.3.
+- The bundled version of HDF5 in `hdf5-src` is now 2.0.0.
 
 ### Fixed
 
diff --git a/Cargo.toml b/Cargo.toml
index ab4da6c6..19c2c23f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,11 +9,12 @@ rust-version = "1.92"
 authors = [
     "Ivan Smirnov <aldanor@users.noreply.github.com>",
     "Magnus Ulimoen <mulimoen@users.noreply.github.com>",
+    "Archebase Contributors <archebase@users.noreply.github.com>",
 ]
 keywords = ["hdf5"]
 license = "MIT OR Apache-2.0"
-repository = "https://github.com/aldanor/hdf5-rust"
-homepage = "https://github.com/aldanor/hdf5-rust"
+repository = "https://github.com/archebase/hdf5-rs"
+homepage = "https://github.com/archebase/hdf5-rs"
 edition = "2021"
 
 [workspace.dependencies]
diff --git a/Claude.md b/Claude.md
index 765009da..c58f3baf 100644
--- a/Claude.md
+++ b/Claude.md
@@ -1,353 +1,184 @@
-# Strata - Embodiment AI Query Engine
+# HDF5-Rust
 
-This is the Strata project, a domain-specific query engine for embodiment AI data.
+Rust bindings for the HDF5 library, providing safe idiomatic Rust wrappers around low-level FFI bindings.
 
 ## Project Structure
 
-```
-strata/
-├── api/                    # Go API layer (Fiber framework)
-│   ├── cmd/strata-api/     # Main entry point
-│   └── internal/           # Internal packages (handlers, middleware, services)
-├── engine/                 # Query engine (Rust + Python)
-│   ├── strata-core/        # Rust core (DataFusion extensions)
-│   ├── strata-flight/      # Arrow Flight SQL server and CLI
-│   ├── strata-python/      # PyO3 Python bindings
-│   └── strata/             # Python package
-├── catalog/                # MySQL migrations
-└── deploy/                 # Docker, K8s configs
-```
-
-## Key Technologies
-
-- **DataFusion (Rust)**: Core query engine with SQL parsing, optimization, execution
-- **Arrow Flight SQL**: High-performance gRPC protocol for database connectivity (port 50051)
-- **PyO3**: Rust-Python bindings for the query engine
-- **Go (Fiber)**: REST API layer with auth, rate limiting
-- **MySQL**: Catalog for dataset metadata, UDFs, query logs
-- **Lance**: Columnar format with vector search for embeddings
-- **Ray**: Distributed execution for materialization and Python UDF parallelization
-
-## Design Documentation
-
-Design documents live in `design/`. These describe what we're building and why—not how to use the system.
+This is a Cargo workspace with multiple interdependent crates:
 
 ```
-design/
-├── README.md                    # Design doc index
-├── DEVELOPMENT.md               # Developer setup guide
-│
-├── data_ingestion/              # Data ingestion feature
-│   ├── overview.md              # Core concepts, SQL syntax
-│   ├── bag_support.md           # Phase 3c: BAG design
-│   ├── ray_integration.md       # Phase 3d: Ray design
-│   └── status.md                # Implementation status, task lists
-│
-└── distributed_query/           # Distributed query feature
-    └── strategy.md
+hdf5-rust/
+├── hdf5/                    # Main library - high-level HDF5 API
+├── hdf5-types/              # Native Rust equivalents of HDF5 types
+├── hdf5-derive/             # Procedural macro for deriving H5Type trait
+├── hdf5-sys/                # Low-level FFI bindings to HDF5 C library
+├── hdf5-src/                # Build scripts for compiling HDF5 from source
+├── tests/                   # Integration tests
+└── .github/workflows/       # CI configuration
 ```
 
-### Design Doc Conventions
-
-1. **One feature per folder** — Group related design docs together (e.g., `data_ingestion/`, `distributed_query/`)
-
-2. **Separate design from status** — Design docs describe architecture; `status.md` tracks implementation progress
-
-3. **Feature-scoped status** — Each feature folder has its own `status.md` with:
-   - Implementation phases with checkboxes
-   - Component status table
-   - Task lists
-
-4. **Use `design/` for internal docs** — User-facing documentation (tutorials, how-to guides) goes in `docs/` (future)
-
-### Writing a Design Doc
-
-Start with a clear problem statement and proposed solution:
-
-```markdown
-# Feature Name Design
+## Key Technologies
 
-## Problem Statement
-What problem are we solving?
+- **HDF5 C Library**: Hierarchical Data Format for scientific data
+- **Rust FFI**: Low-level bindings to libhdf5
+- **Procedural Macros**: `#[derive(H5Type)]` for automatic type mappings
+- **CMake**: For building bundled HDF5 from source
+- **pkg-config**: For finding system HDF5 installations
 
-## Proposed Solution
-High-level architecture and approach.
+## Build System
 
-## Detailed Design
-- Component diagrams
-- Data structures
-- API contracts
+### Features
 
-## Implementation Plan
-Phase 1, Phase 2, ...
+Main features in the `hdf5` crate:
+- `static`: Compile and statically link bundled HDF5
+- `zlib`: Enable zlib compression filter
+- `lzf`: Enable LZF compression filter
+- `blosc`: Enable blosc compression filters
+- `mpio`: Enable MPI parallel support
+- `complex`: Enable complex number types
+- `f16`: Enable float16 type support
 
-## Open Questions
-Unresolved issues for discussion
-```
+### Version-Based Features
 
-Reference existing design docs for style:
-- `design/data_ingestion/overview.md` — Broad feature overview
-- `design/data_ingestion/bag_support.md` — Specific component design
-- `design/distributed_query/strategy.md` — Strategic analysis
+Features are auto-enabled based on detected HDF5 version:
+- `1_8_4`, `1_8_5`, ..., `1_14_4`: Specific HDF5 version support
+- `hdf5_1_10_0`, `hdf5_1_12_0`, etc.: Major version milestones
 
-## Development Commands
+### Building
 
 ```bash
-make dev-up              # Start infrastructure (MySQL, MinIO, Ray)
-make build               # Build all components
-make test                # Run all tests
-make run-api             # Start the API server
-make run-flight-server   # Start Arrow Flight SQL server (port 50051)
-make strata-cli          # Run CLI client (ARGS="--query 'SELECT 1'")
-make help                # Show all commands
-```
-
-## Claude Code Guidelines
-
-When working on this project:
-
-1. **API Changes**: Go code in `api/`. Use Fiber conventions, add handlers to `internal/handler/`.
-2. **Query Engine**: Rust code in `engine/strata-core/`. DataFusion extensions, UDFs, table providers.
-3. **Flight SQL**: Rust code in `engine/strata-flight/`. Server, session management, CLI client.
-4. **Python Bindings**: `engine/strata-python/` for PyO3 bindings, `engine/strata/` for Python API.
-5. **Database**: Add migrations to `catalog/migrations/` with sequential numbering.
-
-### Code Style
-
-- **Rust**: Use `cargo fmt` and `cargo clippy`
-- **Python**: Use `black` and `ruff`
-- **Go**: Use `gofmt` and standard Go conventions
-
-#### Example Naming Convention
-
-In code comments, documentation, and examples, use the consistent naming sequence:
-- **foo** - First example item
-- **bar** - Second example item
-- **baz** - Third example item
-- **pux** - Fourth example item (used when a fourth distinct example is needed)
-
-This convention applies to:
-- Variable names in code comments
-- Type names in documentation examples
-- Function/method names in examples
-- File names in examples
-
-```
-// Good: Uses standard example names
-let foo_type = "foo/Msg";
-let bar_type = "bar/Msg";
-let baz_type = "baz/Msg";
-let pux_type = "pux/Msg";
-
-// Bad: Uses inconsistent naming
-let alpha = "alpha/Msg";
-let beta = "beta/Msg";
-let gamma = "gamma/Msg";
-```
-
-### Testing
-
-#### Test Levels
-
-1. **Unit Tests**: Test individual components in isolation
-   - Located in `tests/<component>_tests.rs` files
-   - Fast, no external dependencies
-   - Example: `ros1_decoder_tests.rs`, `topic_mapper_tests.rs`
-
-2. **Integration Tests**: Test component interactions using direct library calls
-   - Located in `tests/<component>_integration_tests.rs` or `tests/<component>_converter_tests.rs`
-   - May use `StrataSession` directly
-   - Example: `bag_converter_tests.rs`, `mcap_integration_tests.rs`
-
-3. **E2E Tests**: Test the full system through network protocols
-   - Located in `strata-flight/tests/strata_sql_tests.rs` (Rust) or `tests/e2e/` (Python)
-   - Start Flight SQL server as a separate process
-   - Use `strata-cli` or Flight SQL client to execute commands
-   - Run with `make test-e2e`
+cargo build                   # Build with system HDF5
+cargo build --features static  # Build with bundled HDF5
+cargo test                     # Run all tests
+cargo fmt                      # Format code
+cargo clippy                   # Run linter
+```
+
+## Code Organization
+
+### High-Level API (hdf5/src/)
+
+Core modules:
+- `error.rs`: Error handling with `H5Error` and `Result` types
+- `globals.rs`: Global library initialization and state
+- `sync.rs`: Thread safety (reentrant mutexes for non-threadsafe libhdf5)
+- `handle.rs`: Handle management for HDF5 objects
+- `dim.rs`: Dimension utilities
+
+High-level API (`hl/` directory):
+- `file.rs`: File operations
+- `group.rs`: Group (directory-like) operations
+- `dataset.rs`: Dataset operations
+- `datatype.rs`: Type definitions
+- `dataspace.rs`: Data space and dimensions
+- `attribute.rs`: Attribute operations
+- `object.rs`: Generic object operations
+- `location.rs`: Location/namespace management
+
+Property lists (`plist/` directory):
+- File creation/access properties
+- Dataset creation/access properties
+- Link creation properties
+
+### Low-Level FFI (hdf5-sys/src/)
+
+Organized by HDF5 C modules:
+- `h5.rs`: Core HDF5 functions
+- `h5a.rs`: Attributes (H5A_* functions)
+- `h5d.rs`: Datasets (H5D_* functions)
+- `h5f.rs`: Files (H5F_* functions)
+- `h5g.rs`: Groups (H5G_* functions)
+- `h5t.rs`: Datatypes (H5T_* functions)
+- `h5s.rs`: Dataspaces (H5S_* functions)
+- `h5p.rs`: Property lists (H5P_* functions)
+- And others (h5i, h5l, h5o, h5z, etc.)
+
+Each FFI file uses:
+- `pub unsafe fn` for raw C function bindings
+- `extern "C"` for C ABI
+- Type-safe wrappers where applicable
+
+## Development Guidelines
+
+### When Adding New HDF5 Functions
+
+1. **FFI Layer (hdf5-sys)**: Add raw bindings to appropriate `h5*.rs` file
+2. **High-Level Wrapper (hdf5/hl/)**: Create safe Rust wrappers
+3. **Feature Gates**: Use `cfg(feature = "1_XX_X")` for version-specific APIs
+4. **Tests**: Add tests in `hdf5/tests/`
+
+### Error Handling
+
+All HDF5 functions can fail. Use the `Result` type:
 
-#### Test Naming Convention
-
-Use descriptive names that clearly state what is being tested and the expected behavior:
+```rust
+use hdf5::Result;
 
+fn do_something() -> Result<()> {
+    let file = hdf5::File::open("data.h5")?;
+    // ...
+    Ok(())
+}
 ```
-test_<subject>_<behavior_or_condition>
-```
-
-Patterns by test type:
-- **Success cases**: `test_<component>_<action>_<input_or_condition>`
-  - `test_reader_opens_valid_bag_file`
-  - `test_decoder_creates_successfully`
-
-- **Error cases**: `test_<component>_<action>_for_<error_condition>`
-  - `test_reader_returns_error_for_nonexistent_file`
-  - `test_decode_without_schema_returns_error`
 
-- **Mapping/transformation**: `test_<component>_maps_<input>_to_<output>`
-  - `test_mapper_maps_joint_state_to_joint_states_stream`
-  - `test_mapper_maps_image_to_video_frames_stream`
+### Thread Safety
 
-- **Property assertions**: `test_<component>_<property>_<assertion>`
-  - `test_reader_messages_have_valid_timestamps`
-  - `test_reader_connections_contains_valid_metadata`
+The HDF5 C library is not thread-safe by default. The library uses reentrant mutexes:
+- Global initialization in `globals.rs`
+- Handle locking via `sync.rs`
+- Do not call HDF5 functions from multiple threads without proper synchronization
 
-Examples:
-- `test_reader_opens_valid_bag_file` - Good: clear subject and behavior
-- `test_decode_int32_returns_correct_field` - Good: specific input and outcome
-- `test_bag_reader` - Bad: too vague, doesn't describe what's being tested
+### Type Derivation
 
-#### Test File Organization
+Use the derive macro for custom types:
 
-```
-engine/strata-core/tests/
-├── common/
-│   └── mod.rs                # Shared utilities, fixtures, assertions
-├── ros1_decoder_tests.rs     # Unit tests for Ros1Decoder
-├── bag_reader_tests.rs       # Unit tests for BagReader
-├── bag_converter_tests.rs    # Integration tests for BAG conversion
-├── topic_mapper_tests.rs     # Unit tests for TopicMapper
-├── mcap_tests.rs             # Unit tests for MCAP reader
-├── mcap_integration_tests.rs     # Integration tests for MCAP conversion
-└── session_integration_tests.rs  # StrataSession integration tests
-
-engine/strata-flight/tests/
-├── common/
-│   └── mod.rs                # Flight SQL test utilities
-├── query_tests.rs            # Flight SQL query tests
-├── metadata_tests.rs         # Flight SQL metadata tests
-├── prepared_stmt_tests.rs    # Prepared statement tests
-├── transaction_tests.rs      # Transaction handling tests
-├── doput_tests.rs            # DoPut operation tests
-├── tls_tests.rs              # TLS/security tests
-└── strata_sql_tests.rs       # Strata SQL syntax E2E tests (BAG/MCAP)
-
-tests/e2e/
-└── test_e2e.py               # Python E2E tests using subprocess
+```rust
+#[derive(H5Type)]
+struct MyData {
+    x: i32,
+    y: f64,
+}
 ```
 
-#### Shared Test Utilities
+## Testing
 
-Use the `common` module for shared test utilities:
+### Test Organization
 
-```rust
-mod common;
+- `hdf5/tests/`: Integration tests
+- `dataset_test.rs`: Dataset operations
+- `test_plist.rs`: Property lists
+- `test_real_file.rs`: Real file I/O tests
+- `common/dataset_test_utils.rs`: Shared utilities
 
-#[test]
-fn test_example() {
-    let bag_path = common::bag_demo_fixture();
-    skip_if_missing!(&bag_path, "demo.bag");
+### Running Tests
 
-    // Use common assertions
-    common::assert_lance_dataset_valid(&output_path);
-}
+```bash
+cargo test                      # Run all tests
+cargo test --features static    # Test with bundled HDF5
+cargo test --no-fail-fast       # Don't stop on first failure
 ```
 
-Available utilities:
-- `fixtures_dir()`, `bag_demo_fixture()`, `mcap_nissan_fixture()` - Fixture paths
-- `temp_output_dir()`, `temp_file_with_content()` - Temporary files
-- `assert_lance_dataset_valid()`, `assert_episodes_subdataset_exists()` - Lance assertions
-- `assert_error_contains()`, `assert_is_error()` - Error assertions
-- `default_bag_convert_options()`, `default_mcap_convert_options()` - Default options
-- `Ros1MessageBuilder` - Build test message data
+## CI/CD
 
-#### Writing Good Assertions
+GitHub Actions (`.github/workflows/ci.yml`) tests:
+- Linux (Ubuntu with system HDF5)
+- macOS (Homebrew HDF5)
+- Windows (vcpkg HDF5)
+- Static builds (bundled HDF5)
+- Feature matrix
+- MSRV compliance
 
-Always include context in assertions:
+## Current Work
 
-```rust
-// Bad - no context on failure
-assert!(result.is_ok());
-assert!(count > 0);
-
-// Good - clear failure message
-assert!(
-    result.is_ok(),
-    "Expected successful conversion, got error: {:?}",
-    result.err()
-);
-assert!(
-    count > 0,
-    "Expected at least one message, got {}",
-    count
-);
-```
-
-#### Running Tests
+The project is undergoing updates for HDF5 1.14.4 support:
+- MSRV bumped to 1.92
+- Rust edition 2024
+- Modernized dependency syntax
+- Enhanced feature gating
 
-```bash
-make test                 # Run all tests
-make test-engine          # Run Rust engine tests only
-cd engine && cargo test   # Run Rust tests with output
-cd engine && cargo test -- --nocapture  # Show println! output
-make test-e2e             # Run E2E tests (starts Flight server)
-```
+## Code Style
 
-### Task Management with Todo Lists
-
-For complicated tasks involving multiple components or phases, always use todo lists to track progress:
-
-1. **When to Create a Todo List**:
-   - Multi-file changes spanning different modules
-   - Implementation of design documents with multiple phases
-   - Bug fixes requiring investigation across components
-   - Any task with 3+ distinct steps
-
-2. **Todo List Structure**:
-   - Group items by logical phases or components
-   - Use `===` prefix for phase headers (e.g., `=== Phase 1: Foundation ===`)
-   - Mark status: `completed`, `in_progress`, or `pending`
-   - Only one item should be `in_progress` at a time
-
-3. **Maintaining the Todo List**:
-   - Update status immediately when completing a task
-   - Add new items discovered during implementation
-   - Remove items that become irrelevant
-   - Keep the list visible to track overall progress
-
-4. **Example Todo List for Multi-Phase Implementation**:
-   ```
-   === Phase 1: Core Infrastructure ===
-   [completed] Create base types and traits
-   [completed] Implement worker abstraction
-   [in_progress] Add progress tracking
-
-   === Phase 2: Integration ===
-   [pending] Wire up to existing API
-   [pending] Add SQL command support
-
-   === Testing ===
-   [pending] Unit tests
-   [pending] Integration tests
-   ```
-
-### Debug Scripts
-
-**RULE: All debug/diagnostic scripts go in `src/bin/`, not inline Python/bash scripts.**
-
-When investigating issues or creating diagnostic tools:
-- Create proper Rust binaries in `src/bin/*.rs`
-- Use descriptive names: `check_*.rs`, `debug_*.rs`, `diagnose_*.rs`
-- Build and run with `cargo run --bin <name>` or `cargo build --bin <name>`
-- This ensures debug tools are version-controlled, type-checked, and reusable
-
-**Examples**:
-- `src/bin/mcap_info.rs` - Dump MCAP file info
-- `src/bin/debug_schema.rs` - Examine schema parsing
-- `src/bin/check_bag.rs` - Verify BAG file structure
-
-**When to create debug scripts**:
-- Inspecting MCAP/BAG file contents
-- Verifying schema transformations
-- Tracing decoder behavior
-- Any investigation that benefits from a reusable tool
-
-**Anti-pattern to avoid**:
-```bash
-# DON'T: Use inline Python/bash heredocs
-cat > /tmp/check.py << EOF
-import...
-EOF
-python /tmp/check.py
-
-# DO: Create a proper binary in src/bin/
-cargo run --bin check_mcap
-```
+- Use `cargo fmt` for formatting
+- Use `cargo clippy` for linting
+- Follow Rust naming conventions
+- Document all public APIs
diff --git a/README.md b/README.md
index 31c68c33..05649d40 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,13 @@
-# hdf5-rust
+# hdf5-rs
 
 HDF5 for Rust.
 
-[![Build](https://github.com/aldanor/hdf5-rust/workflows/CI/badge.svg)](https://github.com/aldanor/hdf5-rust/actions?query=branch%3Amaster)
+[![Build](https://github.com/archebase/hdf5-rs/workflows/CI/badge.svg)](https://github.com/archebase/hdf5-rs/actions?query=branch%3Amain)
 [![Latest Version](https://img.shields.io/crates/v/hdf5.svg)](https://crates.io/crates/hdf5)
 [![Documentation](https://docs.rs/hdf5/badge.svg)](https://docs.rs/hdf5)
-[![Changelog](https://img.shields.io/github/v/release/aldanor/hdf5-rust)](https://github.com/aldanor/hdf5-rust/blob/master/CHANGELOG.md)
-![hdf5: rustc 1.51+](https://img.shields.io/badge/hdf5-rustc_1.51+-lightblue.svg)
-[![Total Lines](https://tokei.rs/b1/github/aldanor/hdf5-rust)](https://github.com/aldanor/hdf5-rust)
+[![Changelog](https://img.shields.io/github/v/release/archebase/hdf5-rs)](https://github.com/archebase/hdf5-rs/blob/main/CHANGELOG.md)
+![hdf5: rustc 1.92+](https://img.shields.io/badge/hdf5-rustc_1.92+-lightblue.svg)
+[![Total Lines](https://tokei.rs/b1/github/archebase/hdf5-rs)](https://github.com/archebase/hdf5-rs)
 [![Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
@@ -21,7 +21,7 @@ high-level wrappers for the HDF5 library API. Some of the features include:
 
 Direct low-level bindings are also available and are provided in the `hdf5-sys` crate.
 
-Requires HDF5 library of version 1.8.4 or later.
+Requires HDF5 library of version 1.8.4 or later (including HDF5 2.0.0+).
 
 ## Example
 
@@ -112,12 +112,16 @@ toolchains; macOS Catalina).
 ### Rust
 
 `hdf5` crate is tested continuously for all three official release channels, and
-requires a reasonably recent Rust compiler (e.g. of version 1.51 or newer).
+requires a reasonably recent Rust compiler (version 1.92 or newer).
 
 ### HDF5
 
-Required HDF5 version is 1.8.4 or newer. The library doesn't have to be built with
-threadsafe option enabled in order to make the user code threadsafe.
+Required HDF5 version is 1.8.4 or newer, including HDF5 2.0.0+. The library doesn't 
+have to be built with threadsafe option enabled in order to make the user code threadsafe.
+
+Note: HDF5 2.0.0 introduces new features including complex number datatypes, bfloat16,
+and FP8 floating point types. Some of these features require version-specific API bindings
+that are conditionally compiled based on the detected HDF5 version.
 
 Various HDF5 installation options are supported and tested: via package managers
 like homebrew and apt; system-wide installations on Windows; conda installations 
@@ -194,6 +198,15 @@ Few things to note when building on Windows:
 - The recommended setup for `msvc` target is VS2015 x64 since that matches CI build configuration,
   however VS2013 and x86 should work equally well.
 
+## Credits
+
+This project is a fork of [hdf5-rust](https://github.com/aldanor/hdf5-rust), originally created and maintained by:
+
+- **Ivan Smirnov** ([@aldanor](https://github.com/aldanor)) - Original author and maintainer
+- **Magnus Ulimoen** ([@mulimoen](https://github.com/mulimoen)) - Major contributor and co-maintainer
+
+We are grateful for their excellent work in creating and maintaining the original HDF5 Rust bindings.
+
 ## License
 
 `hdf5` crate is primarily distributed under the terms of both the MIT license and the
diff --git a/hdf5-src/build.rs b/hdf5-src/build.rs
index c6bcc150..3dd385b8 100644
--- a/hdf5-src/build.rs
+++ b/hdf5-src/build.rs
@@ -65,6 +65,9 @@ fn main() {
     let targeting_windows = env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows";
     let debug_postfix = if targeting_windows { "_D" } else { "_debug" };
 
+    // HDF5 2.0+ no longer adds debug postfix by default, so we set it explicitly
+    cfg.define("CMAKE_DEBUG_POSTFIX", debug_postfix);
+
     if feature_enabled("HL") {
         cfg.define("HDF5_BUILD_HL_LIB", "ON");
         let mut hdf5_hl_lib =
diff --git a/hdf5-src/ext/hdf5 b/hdf5-src/ext/hdf5
index f0ecc8bc..a6ff8aed 160000
--- a/hdf5-src/ext/hdf5
+++ b/hdf5-src/ext/hdf5
@@ -1 +1 @@
-Subproject commit f0ecc8bc26972119fb31b1cd548ea23fff4a3227
+Subproject commit a6ff8aed236ee1e1deff6415e88b16c42b22f17c
diff --git a/hdf5-sys/Cargo.toml b/hdf5-sys/Cargo.toml
index e80e9411..ce60d452 100644
--- a/hdf5-sys/Cargo.toml
+++ b/hdf5-sys/Cargo.toml
@@ -57,9 +57,11 @@ unexpected_cfgs = { level = "warn", check-cfg = [
     'cfg(hdf5_1_10_5)', 'cfg(hdf5_1_10_6)', 'cfg(hdf5_1_10_7)', 'cfg(hdf5_1_10_8)', 'cfg(hdf5_1_10_9)', 'cfg(hdf5_1_10_10)',
     'cfg(hdf5_1_12_0)', 'cfg(hdf5_1_12_1)', 'cfg(hdf5_1_12_2)',
     'cfg(hdf5_1_14_0)', 'cfg(hdf5_1_14_1)', 'cfg(hdf5_1_14_2)', 'cfg(hdf5_1_14_3)', 'cfg(hdf5_1_14_4)',
+    'cfg(hdf5_2_0_0)', 'cfg(hdf5_2_0_1)', 'cfg(hdf5_2_0_2)', 'cfg(hdf5_2_0_3)',
     'cfg(feature, values("have-parallel", "have-direct"))',
     'cfg(feature, values("1.8.4", "1.8.5", "1.8.6", "1.8.7", "1.8.8", "1.8.9", "1.8.10", "1.8.11", "1.8.12", "1.8.13", "1.8.14", "1.8.15", "1.8.16", "1.8.17", "1.8.18", "1.8.19", "1.8.20", "1.8.21"))',
     'cfg(feature, values("1.10.0", "1.10.1", "1.10.2", "1.10.3", "1.10.4", "1.10.5", "1.10.6", "1.10.7", "1.10.8", "1.10.9", "1.10.10"))',
     'cfg(feature, values("1.12.0", "1.12.1", "1.12.2"))',
     'cfg(feature, values("1.14.0", "1.14.1", "1.14.2", "1.14.3", "1.14.4"))',
+    'cfg(feature, values("2.0.0", "2.0.1", "2.0.2", "2.0.3"))',
 ] }
diff --git a/hdf5-sys/README.md b/hdf5-sys/README.md
index 228e1221..4581b5a9 100644
--- a/hdf5-sys/README.md
+++ b/hdf5-sys/README.md
@@ -9,8 +9,8 @@ This crate supports linking to a static build of HDF5. The HDF5 C library is bui
 via the `hdf5-src` crate which is then linked in when the `static` feature is set.
 See below for a list of supported options for static builds.
 
-As of the time of writing, the version of the HDF5 library that is built is 1.10.5,
-but it may be incremented later.
+As of the time of writing, the version of the HDF5 library that is built is 2.0.0.
+Dynamic linking supports HDF5 versions 1.8.4 through 2.0.x.
 
 ## Crate features
 
diff --git a/hdf5-sys/build.rs b/hdf5-sys/build.rs
index 26da78a5..51b9ec99 100644
--- a/hdf5-sys/build.rs
+++ b/hdf5-sys/build.rs
@@ -4,7 +4,7 @@
 use std::convert::TryInto;
 use std::env;
 use std::error::Error;
-use std::fmt::{self, Debug, Display};
+use std::fmt::{self, Debug};
 use std::fs;
 use std::os::raw::{c_int, c_uint};
 use std::path::{Path, PathBuf};
@@ -29,7 +29,9 @@ impl Version {
     }
 
     pub fn parse(s: &str) -> Option<Self> {
-        let re = Regex::new(r"^(1)\.(8|10|12|14)\.(\d\d?)(_|.\d+)?((-|.)(patch)?\d+)?$").ok()?;
+        // Match HDF5 1.x versions (1.8, 1.10, 1.12, 1.14) and 2.x versions (2.0, etc.)
+        let re =
+            Regex::new(r"^(1|2)\.(0|8|10|12|14)\.(\d\d?)(_|.\d+)?((-|.)(patch)?\d+)?$").ok()?;
         let captures = re.captures(s)?;
         Some(Self {
             major: captures.get(1).and_then(|c| c.as_str().parse::<u8>().ok())?,
@@ -39,7 +41,9 @@ impl Version {
     }
 
     pub fn is_valid(self) -> bool {
+        // Accept HDF5 1.8.4+ or HDF5 2.0.0+
         self >= Self { major: 1, minor: 8, micro: 4 }
+            || self >= Self { major: 2, minor: 0, micro: 0 }
     }
 }
 
@@ -80,18 +84,6 @@ fn is_msvc() -> bool {
     std::env::var("CARGO_CFG_TARGET_ENV").unwrap() == "msvc"
 }
 
-#[allow(dead_code)]
-#[derive(Clone, Debug)]
-struct RuntimeError(String);
-
-impl Error for RuntimeError {}
-
-impl Display for RuntimeError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "HDF5 runtime error: {}", self.0)
-    }
-}
-
 #[allow(non_snake_case, non_camel_case_types)]
 fn get_runtime_version_single<P: AsRef<Path>>(path: P) -> Result<Version, Box<dyn Error>> {
     type H5open_t = unsafe extern "C" fn() -> c_int;
@@ -336,15 +328,16 @@ mod macos {
         }
         // We have to explicitly support homebrew since the HDF5 bottle isn't
         // packaged with pkg-config metadata.
-        let (v18, v110, v112, v114) = if let Some(version) = config.version {
+        let (v18, v110, v112, v114, v20) = if let Some(version) = config.version {
             (
                 version.major == 1 && version.minor == 8,
                 version.major == 1 && version.minor == 10,
                 version.major == 1 && version.minor == 12,
                 version.major == 1 && version.minor == 14,
+                version.major == 2 && version.minor == 0,
             )
         } else {
-            (false, false, false, false)
+            (false, false, false, false, false)
         };
         println!(
             "Attempting to find HDF5 via Homebrew ({})...",
@@ -356,32 +349,42 @@ mod macos {
                 "1.12.*"
             } else if v114 {
                 "1.14.*"
+            } else if v20 {
+                "2.0.*"
             } else {
                 "any version"
             }
         );
-        if !(v18 || v110 || v112) {
+        // Try HDF5 2.0 first (if not requesting a specific 1.x version)
+        if !(v18 || v110 || v112 || v114) {
+            if let Some(out) = run_command("brew", &["--prefix", "hdf5"]) {
+                if is_root_dir(&out) {
+                    config.inc_dir = Some(PathBuf::from(out).join("include"));
+                }
+            }
+        }
+        if config.inc_dir.is_none() && !(v18 || v110 || v112 || v20) {
             if let Some(out) = run_command("brew", &["--prefix", "hdf5@1.14"]) {
                 if is_root_dir(&out) {
                     config.inc_dir = Some(PathBuf::from(out).join("include"));
                 }
             }
         }
-        if !(v18 || v110) {
+        if config.inc_dir.is_none() && !(v18 || v110 || v20) {
             if let Some(out) = run_command("brew", &["--prefix", "hdf5@1.12"]) {
                 if is_root_dir(&out) {
                     config.inc_dir = Some(PathBuf::from(out).join("include"));
                 }
             }
         }
-        if config.inc_dir.is_none() && !v18 {
+        if config.inc_dir.is_none() && !(v18 || v20) {
             if let Some(out) = run_command("brew", &["--prefix", "hdf5@1.10"]) {
                 if is_root_dir(&out) {
                     config.inc_dir = Some(PathBuf::from(out).join("include"));
                 }
             }
         }
-        if config.inc_dir.is_none() {
+        if config.inc_dir.is_none() && !v20 {
             if let Some(out) = run_command("brew", &["--prefix", "hdf5@1.8"]) {
                 if is_root_dir(&out) {
                     config.inc_dir = Some(PathBuf::from(out).join("include"));
@@ -657,11 +660,15 @@ impl Config {
 
     pub fn emit_cfg_flags(&self) {
         let version = self.header.version;
-        assert!(version >= Version::new(1, 8, 4), "required HDF5 version: >=1.8.4");
-        let mut vs: Vec<_> = (5..=21).map(|v| Version::new(1, 8, v)).collect(); // 1.8.[5-23]
-        vs.extend((0..=8).map(|v| Version::new(1, 10, v))); // 1.10.[0-10]
+        assert!(
+            version >= Version::new(1, 8, 4) || version >= Version::new(2, 0, 0),
+            "required HDF5 version: >=1.8.4 or >=2.0.0"
+        );
+        let mut vs: Vec<_> = (5..=21).map(|v| Version::new(1, 8, v)).collect(); // 1.8.[5-21]
+        vs.extend((0..=10).map(|v| Version::new(1, 10, v))); // 1.10.[0-10]
         vs.extend((0..=2).map(|v| Version::new(1, 12, v))); // 1.12.[0-2]
-        vs.extend((0..=2).map(|v| Version::new(1, 14, v))); // 1.14.[0-2]
+        vs.extend((0..=4).map(|v| Version::new(1, 14, v))); // 1.14.[0-4]
+        vs.extend((0..=3).map(|v| Version::new(2, 0, v))); // 2.0.[0-3]
         for v in vs.into_iter().filter(|&v| version >= v) {
             println!("cargo:rustc-cfg=feature=\"{}.{}.{}\"", v.major, v.minor, v.micro);
             println!("cargo:version_{}_{}_{}=1", v.major, v.minor, v.micro);
@@ -709,7 +716,48 @@ impl Config {
     }
 }
 
+/// Register all custom cfg values to avoid "unexpected cfg" warnings.
+fn register_check_cfg() {
+    // Register all version-based feature flags
+    // 1.8.x versions
+    for v in 5..=21 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"1.8.{}\"))", v);
+    }
+    // 1.10.x versions
+    for v in 0..=10 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"1.10.{}\"))", v);
+    }
+    // 1.12.x versions
+    for v in 0..=2 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"1.12.{}\"))", v);
+    }
+    // 1.14.x versions
+    for v in 0..=4 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"1.14.{}\"))", v);
+    }
+    // 2.0.x versions
+    for v in 0..=3 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"2.0.{}\"))", v);
+    }
+
+    // Register special feature flags
+    println!("cargo::rustc-check-cfg=cfg(feature, values(\"have-parallel\"))");
+    println!("cargo::rustc-check-cfg=cfg(feature, values(\"have-direct\"))");
+    println!("cargo::rustc-check-cfg=cfg(feature, values(\"have-threadsafe\"))");
+    println!("cargo::rustc-check-cfg=cfg(feature, values(\"have-filter-deflate\"))");
+
+    // Register bare cfg names used in source files
+    println!("cargo::rustc-check-cfg=cfg(have_stdbool_h)");
+    println!("cargo::rustc-check-cfg=cfg(hdf5_1_10_1)");
+    println!("cargo::rustc-check-cfg=cfg(hdf5_1_10_2)");
+    println!("cargo::rustc-check-cfg=cfg(hdf5_1_12_0)");
+    println!("cargo::rustc-check-cfg=cfg(hdf5_2_0_0)");
+}
+
 fn main() {
+    // Register all custom cfg values first
+    register_check_cfg();
+
     if feature_enabled("STATIC") && std::env::var_os("HDF5_DIR").is_none() {
         get_build_and_emit();
     } else {
diff --git a/hdf5-sys/src/h5d.rs b/hdf5-sys/src/h5d.rs
index 8e5452ea..64d4a3c4 100644
--- a/hdf5-sys/src/h5d.rs
+++ b/hdf5-sys/src/h5d.rs
@@ -264,11 +264,28 @@ mod hdf5_1_10_0 {
 #[cfg(feature = "1.10.0")]
 pub use self::hdf5_1_10_0::*;
 
-#[cfg(feature = "1.10.3")]
+// H5Dread_chunk: signature changed in HDF5 2.0.0
+#[cfg(all(feature = "1.10.3", not(feature = "2.0.0")))]
 extern "C" {
     pub fn H5Dread_chunk(
         dset_id: hid_t, dxpl_id: hid_t, offset: *const hsize_t, filters: *mut u32, buf: *mut c_void,
     ) -> herr_t;
+}
+
+#[cfg(feature = "2.0.0")]
+extern "C" {
+    #[deprecated(note = "deprecated in HDF5 2.0.0, use H5Dread_chunk2")]
+    pub fn H5Dread_chunk1(
+        dset_id: hid_t, dxpl_id: hid_t, offset: *const hsize_t, filters: *mut u32, buf: *mut c_void,
+    ) -> herr_t;
+    pub fn H5Dread_chunk2(
+        dset_id: hid_t, dxpl_id: hid_t, offset: *const hsize_t, filters: *mut u32,
+        buf: *mut c_void, buf_size: *mut size_t,
+    ) -> herr_t;
+}
+
+#[cfg(feature = "1.10.3")]
+extern "C" {
     pub fn H5Dwrite_chunk(
         dset_id: hid_t, dxpl_id: hid_t, filters: u32, offset: *const hsize_t, data_size: size_t,
         buf: *const c_void,
diff --git a/hdf5-sys/src/h5fd.rs b/hdf5-sys/src/h5fd.rs
index 157d247a..bd79ea19 100644
--- a/hdf5-sys/src/h5fd.rs
+++ b/hdf5-sys/src/h5fd.rs
@@ -364,7 +364,8 @@ extern "C" {
     pub fn H5FDtruncate(file: *mut H5FD_t, dxpl_id: hid_t, closing: hbool_t) -> herr_t;
 }
 
-// drivers
+// drivers - HDF5 2.0 changed to use global variables instead of init functions
+#[cfg(not(feature = "2.0.0"))]
 extern "C" {
     pub fn H5FD_sec2_init() -> hid_t;
     pub fn H5FD_core_init() -> hid_t;
@@ -374,16 +375,37 @@ extern "C" {
     pub fn H5FD_multi_init() -> hid_t;
 }
 
-#[cfg(feature = "have-parallel")]
+// HDF5 2.0.0+: Driver IDs are exposed as global variables
+#[cfg(feature = "2.0.0")]
+extern "C" {
+    pub static H5FD_SEC2_id_g: hid_t;
+    pub static H5FD_CORE_id_g: hid_t;
+    pub static H5FD_STDIO_id_g: hid_t;
+    pub static H5FD_FAMILY_id_g: hid_t;
+    pub static H5FD_LOG_id_g: hid_t;
+    pub static H5FD_MULTI_id_g: hid_t;
+}
+
+#[cfg(all(feature = "have-parallel", not(feature = "2.0.0")))]
 extern "C" {
     pub fn H5FD_mpio_init() -> hid_t;
 }
 
-#[cfg(feature = "have-direct")]
+#[cfg(all(feature = "have-parallel", feature = "2.0.0"))]
+extern "C" {
+    pub static H5FD_MPIO_id_g: hid_t;
+}
+
+#[cfg(all(feature = "have-direct", not(feature = "2.0.0")))]
 extern "C" {
     pub fn H5FD_direct_init() -> hid_t;
 }
 
+#[cfg(all(feature = "have-direct", feature = "2.0.0"))]
+extern "C" {
+    pub static H5FD_DIRECT_id_g: hid_t;
+}
+
 #[cfg(feature = "1.10.0")]
 extern "C" {
     pub fn H5FDlock(file: *mut H5FD_t, rw: hbool_t) -> herr_t;
diff --git a/hdf5-sys/src/h5i.rs b/hdf5-sys/src/h5i.rs
index 9fb1578a..6a4a3ed7 100644
--- a/hdf5-sys/src/h5i.rs
+++ b/hdf5-sys/src/h5i.rs
@@ -62,6 +62,8 @@ extern "C" {
     pub fn H5Iinc_ref(id: hid_t) -> c_int;
     pub fn H5Idec_ref(id: hid_t) -> c_int;
     pub fn H5Iget_ref(id: hid_t) -> c_int;
+    // H5Iregister_type: signature changed in HDF5 2.0.0 (hash_size removed)
+    #[cfg(not(feature = "2.0.0"))]
     pub fn H5Iregister_type(
         hash_size: size_t, reserved: c_uint, free_func: H5I_free_t,
     ) -> H5I_type_t;
@@ -94,3 +96,13 @@ extern "C" {
         discard_cb: H5I_future_discard_func_t,
     ) -> hid_t;
 }
+
+// H5Iregister_type: signature changed in HDF5 2.0.0 (hash_size removed)
+#[cfg(feature = "2.0.0")]
+extern "C" {
+    #[deprecated(note = "deprecated in HDF5 2.0.0, use H5Iregister_type2")]
+    pub fn H5Iregister_type1(
+        hash_size: size_t, reserved: c_uint, free_func: H5I_free_t,
+    ) -> H5I_type_t;
+    pub fn H5Iregister_type2(reserved: c_uint, free_func: H5I_free_t) -> H5I_type_t;
+}
diff --git a/hdf5-sys/src/h5t.rs b/hdf5-sys/src/h5t.rs
index 99b2f636..6f2d94f2 100644
--- a/hdf5-sys/src/h5t.rs
+++ b/hdf5-sys/src/h5t.rs
@@ -22,6 +22,8 @@ pub use {
 
 use crate::internal_prelude::*;
 
+// H5T_class_t: H5T_COMPLEX added in HDF5 2.0.0
+#[cfg(not(feature = "2.0.0"))]
 #[repr(C)]
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Debug)]
 pub enum H5T_class_t {
@@ -40,6 +42,26 @@ pub enum H5T_class_t {
     H5T_NCLASSES = 11,
 }
 
+#[cfg(feature = "2.0.0")]
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Debug)]
+pub enum H5T_class_t {
+    H5T_NO_CLASS = -1,
+    H5T_INTEGER = 0,
+    H5T_FLOAT = 1,
+    H5T_TIME = 2,
+    H5T_STRING = 3,
+    H5T_BITFIELD = 4,
+    H5T_OPAQUE = 5,
+    H5T_COMPOUND = 6,
+    H5T_REFERENCE = 7,
+    H5T_ENUM = 8,
+    H5T_VLEN = 9,
+    H5T_ARRAY = 10,
+    H5T_COMPLEX = 11,
+    H5T_NCLASSES = 12,
+}
+
 #[cfg(feature = "1.8.6")]
 #[repr(C)]
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Debug)]
@@ -268,6 +290,7 @@ extern "C" {
     pub fn H5Tget_create_plist(type_id: hid_t) -> hid_t;
     pub fn H5Tcommitted(type_id: hid_t) -> htri_t;
     pub fn H5Tencode(obj_id: hid_t, buf: *mut c_void, nalloc: *mut size_t) -> herr_t;
+    #[cfg(not(feature = "2.0.0"))]
     pub fn H5Tdecode(buf: *const c_void) -> hid_t;
     pub fn H5Tinsert(
         parent_id: hid_t, name: *const c_char, offset: size_t, member_id: hid_t,
@@ -444,6 +467,38 @@ mod globals {
     extern_static!(H5T_NATIVE_UINT_FAST64, H5T_NATIVE_UINT_FAST64_g);
     #[cfg(feature = "1.12.0")]
     extern_static!(H5T_STD_REF, H5T_STD_REF_g);
+
+    // HDF5 2.0.0: Complex number datatypes
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F16BE, H5T_COMPLEX_IEEE_F16BE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F16LE, H5T_COMPLEX_IEEE_F16LE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F32BE, H5T_COMPLEX_IEEE_F32BE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F32LE, H5T_COMPLEX_IEEE_F32LE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F64BE, H5T_COMPLEX_IEEE_F64BE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F64LE, H5T_COMPLEX_IEEE_F64LE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_NATIVE_FLOAT_COMPLEX, H5T_NATIVE_FLOAT_COMPLEX_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_NATIVE_DOUBLE_COMPLEX, H5T_NATIVE_DOUBLE_COMPLEX_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_NATIVE_LDOUBLE_COMPLEX, H5T_NATIVE_LDOUBLE_COMPLEX_g);
+
+    // HDF5 2.0.0: bfloat16 datatypes
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_FLOAT_BFLOAT16BE, H5T_FLOAT_BFLOAT16BE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_FLOAT_BFLOAT16LE, H5T_FLOAT_BFLOAT16LE_g);
+
+    // HDF5 2.0.0: FP8 datatypes
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_FLOAT_F8E4M3, H5T_FLOAT_F8E4M3_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_FLOAT_F8E5M2, H5T_FLOAT_F8E5M2_g);
 }
 
 #[cfg(all(target_env = "msvc", not(feature = "static")))]
@@ -539,6 +594,38 @@ mod globals {
     extern_static!(H5T_NATIVE_UINT_FAST64, __imp_H5T_NATIVE_UINT_FAST64_g);
     #[cfg(feature = "1.12.0")]
     extern_static!(H5T_STD_REF, __imp_H5T_STD_REF_g);
+
+    // HDF5 2.0.0: Complex number datatypes
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F16BE, __imp_H5T_COMPLEX_IEEE_F16BE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F16LE, __imp_H5T_COMPLEX_IEEE_F16LE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F32BE, __imp_H5T_COMPLEX_IEEE_F32BE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F32LE, __imp_H5T_COMPLEX_IEEE_F32LE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F64BE, __imp_H5T_COMPLEX_IEEE_F64BE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_COMPLEX_IEEE_F64LE, __imp_H5T_COMPLEX_IEEE_F64LE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_NATIVE_FLOAT_COMPLEX, __imp_H5T_NATIVE_FLOAT_COMPLEX_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_NATIVE_DOUBLE_COMPLEX, __imp_H5T_NATIVE_DOUBLE_COMPLEX_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_NATIVE_LDOUBLE_COMPLEX, __imp_H5T_NATIVE_LDOUBLE_COMPLEX_g);
+
+    // HDF5 2.0.0: bfloat16 datatypes
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_FLOAT_BFLOAT16BE, __imp_H5T_FLOAT_BFLOAT16BE_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_FLOAT_BFLOAT16LE, __imp_H5T_FLOAT_BFLOAT16LE_g);
+
+    // HDF5 2.0.0: FP8 datatypes
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_FLOAT_F8E4M3, __imp_H5T_FLOAT_F8E4M3_g);
+    #[cfg(feature = "2.0.0")]
+    extern_static!(H5T_FLOAT_F8E5M2, __imp_H5T_FLOAT_F8E5M2_g);
 }
 
 #[cfg(feature = "1.10.0")]
@@ -568,3 +655,18 @@ extern "C" {
         name: *const c_char, tapl_id: hid_t, es_id: hid_t,
     ) -> hid_t;
 }
+
+// H5Tdecode: signature changed in HDF5 2.0.0
+#[cfg(feature = "2.0.0")]
+extern "C" {
+    #[deprecated(note = "deprecated in HDF5 2.0.0, use H5Tdecode2")]
+    pub fn H5Tdecode1(buf: *const c_void) -> hid_t;
+    pub fn H5Tdecode2(buf: *const c_void, buf_size: size_t) -> hid_t;
+}
+
+// HDF5 2.0.0: Complex number datatype support
+#[cfg(feature = "2.0.0")]
+extern "C" {
+    /// Creates a new complex number datatype based on the given base floating-point type
+    pub fn H5Tcomplex_create(base_type_id: hid_t) -> hid_t;
+}
diff --git a/hdf5-sys/src/lib.rs b/hdf5-sys/src/lib.rs
index 0a736fa0..1e5a3fd1 100644
--- a/hdf5-sys/src/lib.rs
+++ b/hdf5-sys/src/lib.rs
@@ -77,4 +77,145 @@ mod tests {
             assert!(*H5P_CLS_ROOT > 0);
         }
     }
+
+    /// HDF5 2.0.0 specific tests
+    #[cfg(feature = "2.0.0")]
+    mod hdf5_2_0 {
+        use crate::h5::H5open;
+        use crate::h5i::hid_t;
+        use crate::h5t::*;
+
+        #[test]
+        fn test_h5t_complex_class_value() {
+            // H5T_COMPLEX should be 11 in HDF5 2.0.0
+            assert_eq!(H5T_class_t::H5T_COMPLEX as i32, 11);
+            assert_eq!(H5T_class_t::H5T_NCLASSES as i32, 12);
+        }
+
+        #[test]
+        fn test_complex_predefined_types_valid() {
+            unsafe {
+                H5open();
+
+                // Verify complex predefined types are valid (non-negative) after H5open
+                assert!(*H5T_COMPLEX_IEEE_F32LE >= 0 as hid_t);
+                assert!(*H5T_COMPLEX_IEEE_F32BE >= 0 as hid_t);
+                assert!(*H5T_COMPLEX_IEEE_F64LE >= 0 as hid_t);
+                assert!(*H5T_COMPLEX_IEEE_F64BE >= 0 as hid_t);
+            }
+        }
+
+        #[test]
+        fn test_bfloat16_predefined_types_valid() {
+            unsafe {
+                H5open();
+
+                // Verify bfloat16 predefined types are valid
+                assert!(*H5T_FLOAT_BFLOAT16LE >= 0 as hid_t);
+                assert!(*H5T_FLOAT_BFLOAT16BE >= 0 as hid_t);
+            }
+        }
+
+        #[test]
+        fn test_fp8_predefined_types_valid() {
+            unsafe {
+                H5open();
+
+                // Verify FP8 predefined types are valid
+                assert!(*H5T_FLOAT_F8E4M3 >= 0 as hid_t);
+                assert!(*H5T_FLOAT_F8E5M2 >= 0 as hid_t);
+            }
+        }
+
+        #[test]
+        fn test_h5tcomplex_create_callable() {
+            use crate::h5t::{H5Tclose, H5Tcomplex_create, H5Tget_class};
+
+            unsafe {
+                H5open();
+
+                // Create a complex type based on native float
+                let complex_type = H5Tcomplex_create(*H5T_NATIVE_FLOAT);
+                if complex_type >= 0 {
+                    // Verify it's a complex type
+                    let cls = H5Tget_class(complex_type);
+                    assert_eq!(cls, H5T_class_t::H5T_COMPLEX);
+                    H5Tclose(complex_type);
+                }
+            }
+        }
+
+        #[test]
+        fn test_versioned_api_h5dread_chunk2() {
+            use crate::h5d::H5Dread_chunk2;
+
+            // Verify function exists and has correct signature
+            let _: unsafe extern "C" fn(
+                crate::h5i::hid_t,
+                crate::h5i::hid_t,
+                *const crate::h5::hsize_t,
+                *mut u32,
+                *mut std::os::raw::c_void,
+                *mut usize,
+            ) -> crate::h5::herr_t = H5Dread_chunk2;
+        }
+
+        #[test]
+        fn test_versioned_api_h5tdecode2() {
+            use crate::h5t::H5Tdecode2;
+
+            // Verify function exists and has correct signature
+            let _: unsafe extern "C" fn(*const std::os::raw::c_void, usize) -> crate::h5i::hid_t =
+                H5Tdecode2;
+        }
+
+        #[test]
+        fn test_versioned_api_h5iregister_type2() {
+            use crate::h5i::{H5I_free_t, H5I_type_t, H5Iregister_type2};
+
+            // Verify function exists and has correct signature
+            let _: unsafe extern "C" fn(std::os::raw::c_uint, H5I_free_t) -> H5I_type_t =
+                H5Iregister_type2;
+        }
+
+        #[test]
+        fn test_deprecated_apis_exist() {
+            // Verify deprecated v1 APIs still exist for backward compatibility
+            #[allow(deprecated)]
+            {
+                use crate::h5d::H5Dread_chunk1;
+                use crate::h5i::H5Iregister_type1;
+                use crate::h5t::H5Tdecode1;
+
+                let _: unsafe extern "C" fn(
+                    crate::h5i::hid_t,
+                    crate::h5i::hid_t,
+                    *const crate::h5::hsize_t,
+                    *mut u32,
+                    *mut std::os::raw::c_void,
+                ) -> crate::h5::herr_t = H5Dread_chunk1;
+
+                let _: unsafe extern "C" fn(*const std::os::raw::c_void) -> crate::h5i::hid_t =
+                    H5Tdecode1;
+
+                let _: unsafe extern "C" fn(
+                    usize,
+                    std::os::raw::c_uint,
+                    crate::h5i::H5I_free_t,
+                ) -> crate::h5i::H5I_type_t = H5Iregister_type1;
+            }
+        }
+    }
+
+    /// Pre-HDF5 2.0.0 tests
+    #[cfg(not(feature = "2.0.0"))]
+    mod pre_hdf5_2_0 {
+        use crate::h5t::H5T_class_t;
+
+        #[test]
+        fn test_h5t_nclasses_without_complex() {
+            // H5T_NCLASSES should be 11 before HDF5 2.0.0
+            assert_eq!(H5T_class_t::H5T_NCLASSES as i32, 11);
+        }
+    }
 }
diff --git a/hdf5-types/build.rs b/hdf5-types/build.rs
index 7419b5eb..7506c8d7 100644
--- a/hdf5-types/build.rs
+++ b/hdf5-types/build.rs
@@ -1,6 +1,8 @@
 fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo::rerun-if-changed=build.rs");
+    // Register the windows_dll cfg to avoid unexpected cfg warnings
+    println!("cargo::rustc-check-cfg=cfg(windows_dll)");
     if std::env::var_os("DEP_HDF5_MSVC_DLL_INDIRECTION").is_some() {
-        println!("cargo:rustc-cfg=windows_dll");
+        println!("cargo::rustc-cfg=windows_dll");
     }
 }
diff --git a/hdf5/Cargo.toml b/hdf5/Cargo.toml
index b56a1f7e..a2ada908 100644
--- a/hdf5/Cargo.toml
+++ b/hdf5/Cargo.toml
@@ -77,6 +77,7 @@ unexpected_cfgs = { level = "warn", check-cfg = [
     'cfg(feature, values("1.10.0", "1.10.1", "1.10.2", "1.10.3", "1.10.4", "1.10.5", "1.10.6", "1.10.7", "1.10.8", "1.10.9", "1.10.10"))',
     'cfg(feature, values("1.12.0", "1.12.1", "1.12.2"))',
     'cfg(feature, values("1.14.0", "1.14.1", "1.14.2", "1.14.3", "1.14.4"))',
+    'cfg(feature, values("2.0.0", "2.0.1", "2.0.2", "2.0.3"))',
 ] }
 # Allow non-camel-case type names for HDF5 driver types (H5FD_*)
 non_camel_case_types = "allow"
diff --git a/hdf5/build.rs b/hdf5/build.rs
index 7a74dbbf..2da24849 100644
--- a/hdf5/build.rs
+++ b/hdf5/build.rs
@@ -1,8 +1,44 @@
 use std::env;
 
+/// Register all custom cfg values to avoid "unexpected cfg" warnings.
+fn register_check_cfg() {
+    // Register all version-based feature flags
+    // 1.8.x versions
+    for v in 5..=21 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"1.8.{}\"))", v);
+    }
+    // 1.10.x versions
+    for v in 0..=8 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"1.10.{}\"))", v);
+    }
+    // 1.12.x versions
+    for v in 0..=2 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"1.12.{}\"))", v);
+    }
+    // 1.14.x versions
+    for v in 0..=1 {
+        println!("cargo::rustc-check-cfg=cfg(feature, values(\"1.14.{}\"))", v);
+    }
+
+    // Register special feature flags
+    println!("cargo::rustc-check-cfg=cfg(feature, values(\"have-parallel\"))");
+    println!("cargo::rustc-check-cfg=cfg(feature, values(\"have-direct\"))");
+    println!("cargo::rustc-check-cfg=cfg(feature, values(\"have-threadsafe\"))");
+    println!("cargo::rustc-check-cfg=cfg(feature, values(\"have-filter-deflate\"))");
+
+    // Register internal config flags
+    println!("cargo::rustc-check-cfg=cfg(msvc_dll_indirection)");
+
+    // Register docsrs cfg for documentation builds
+    println!("cargo::rustc-check-cfg=cfg(docsrs)");
+}
+
 fn main() {
-    let print_feature = |key: &str| println!("cargo:rustc-cfg=feature=\"{}\"", key);
-    let print_cfg = |key: &str| println!("cargo:rustc-cfg={}", key);
+    // Register all custom cfg values first
+    register_check_cfg();
+
+    let print_feature = |key: &str| println!("cargo::rustc-cfg=feature=\"{}\"", key);
+    let print_cfg = |key: &str| println!("cargo::rustc-cfg={}", key);
     for (key, _) in env::vars() {
         match key.as_str() {
             // public features
diff --git a/hdf5/src/globals.rs b/hdf5/src/globals.rs
index 1a43015c..b43814a7 100644
--- a/hdf5/src/globals.rs
+++ b/hdf5/src/globals.rs
@@ -2,16 +2,31 @@
 
 use std::mem;
 use std::ops::Deref;
+#[cfg(not(feature = "2.0.0"))]
 use std::sync::OnceLock;
 
-#[cfg(feature = "have-direct")]
+// HDF5 < 2.0.0: Use init functions for file drivers
+#[cfg(all(feature = "have-direct", not(feature = "2.0.0")))]
 use hdf5_sys::h5fd::H5FD_direct_init;
-#[cfg(feature = "have-parallel")]
+#[cfg(all(feature = "have-parallel", not(feature = "2.0.0")))]
 use hdf5_sys::h5fd::H5FD_mpio_init;
+#[cfg(not(feature = "2.0.0"))]
 use hdf5_sys::h5fd::{
     H5FD_core_init, H5FD_family_init, H5FD_log_init, H5FD_multi_init, H5FD_sec2_init,
     H5FD_stdio_init,
 };
+
+// HDF5 2.0.0+: Use global variables for file drivers
+#[cfg(all(feature = "have-direct", feature = "2.0.0"))]
+use hdf5_sys::h5fd::H5FD_DIRECT_id_g;
+#[cfg(all(feature = "have-parallel", feature = "2.0.0"))]
+use hdf5_sys::h5fd::H5FD_MPIO_id_g;
+#[cfg(feature = "2.0.0")]
+use hdf5_sys::h5fd::{
+    H5FD_CORE_id_g, H5FD_FAMILY_id_g, H5FD_LOG_id_g, H5FD_MULTI_id_g, H5FD_SEC2_id_g,
+    H5FD_STDIO_id_g,
+};
+
 use hdf5_sys::{h5e, h5p, h5t};
 
 use crate::internal_prelude::*;
@@ -331,6 +346,8 @@ pub fn h5r_dset_reg_ref_buf_size() -> usize {
 }
 
 // File drivers - use OnceLock for lazy initialization with Deref for * operator support
+// HDF5 < 2.0.0: Use init functions
+#[cfg(not(feature = "2.0.0"))]
 macro_rules! h5fd_driver_static {
     ($name:ident, $init:ident) => {
         pub struct $name {
@@ -354,22 +371,65 @@ macro_rules! h5fd_driver_static {
     };
 }
 
+// HDF5 2.0.0+: Use global variables directly
+#[cfg(feature = "2.0.0")]
+macro_rules! h5fd_driver_static_2_0 {
+    ($name:ident, $global:ident) => {
+        paste::paste! {
+            pub struct [<$name _Type>];
+
+            impl Deref for [<$name _Type>] {
+                type Target = hid_t;
+                fn deref(&self) -> &Self::Target {
+                    crate::sync::ensure_library_init();
+                    unsafe { &$global }
+                }
+            }
+
+            pub static $name: [<$name _Type>] = [<$name _Type>];
+        }
+    };
+}
+
+#[cfg(not(feature = "2.0.0"))]
 h5fd_driver_static!(H5FD_CORE, H5FD_core_init);
+#[cfg(not(feature = "2.0.0"))]
 h5fd_driver_static!(H5FD_SEC2, H5FD_sec2_init);
+#[cfg(not(feature = "2.0.0"))]
 h5fd_driver_static!(H5FD_STDIO, H5FD_stdio_init);
+#[cfg(not(feature = "2.0.0"))]
 h5fd_driver_static!(H5FD_FAMILY, H5FD_family_init);
+#[cfg(not(feature = "2.0.0"))]
 h5fd_driver_static!(H5FD_LOG, H5FD_log_init);
+#[cfg(not(feature = "2.0.0"))]
 h5fd_driver_static!(H5FD_MULTI, H5FD_multi_init);
 
+#[cfg(feature = "2.0.0")]
+h5fd_driver_static_2_0!(H5FD_CORE, H5FD_CORE_id_g);
+#[cfg(feature = "2.0.0")]
+h5fd_driver_static_2_0!(H5FD_SEC2, H5FD_SEC2_id_g);
+#[cfg(feature = "2.0.0")]
+h5fd_driver_static_2_0!(H5FD_STDIO, H5FD_STDIO_id_g);
+#[cfg(feature = "2.0.0")]
+h5fd_driver_static_2_0!(H5FD_FAMILY, H5FD_FAMILY_id_g);
+#[cfg(feature = "2.0.0")]
+h5fd_driver_static_2_0!(H5FD_LOG, H5FD_LOG_id_g);
+#[cfg(feature = "2.0.0")]
+h5fd_driver_static_2_0!(H5FD_MULTI, H5FD_MULTI_id_g);
+
 // MPI-IO file driver
-#[cfg(feature = "have-parallel")]
+#[cfg(all(feature = "have-parallel", not(feature = "2.0.0")))]
 h5fd_driver_static!(H5FD_MPIO, H5FD_mpio_init);
+#[cfg(all(feature = "have-parallel", feature = "2.0.0"))]
+h5fd_driver_static_2_0!(H5FD_MPIO, H5FD_MPIO_id_g);
 #[cfg(not(feature = "have-parallel"))]
 pub static H5FD_MPIO: hid_t = H5I_INVALID_HID;
 
 // Direct VFD
-#[cfg(feature = "have-direct")]
+#[cfg(all(feature = "have-direct", not(feature = "2.0.0")))]
 h5fd_driver_static!(H5FD_DIRECT, H5FD_direct_init);
+#[cfg(all(feature = "have-direct", feature = "2.0.0"))]
+h5fd_driver_static_2_0!(H5FD_DIRECT, H5FD_DIRECT_id_g);
 #[cfg(not(feature = "have-direct"))]
 pub static H5FD_DIRECT: hid_t = H5I_INVALID_HID;
 
diff --git a/hdf5/src/hl/datatype.rs b/hdf5/src/hl/datatype.rs
index 4a2159e6..6043cd96 100644
--- a/hdf5/src/hl/datatype.rs
+++ b/hdf5/src/hl/datatype.rs
@@ -168,6 +168,13 @@ impl Datatype {
         h5lock!(H5Tget_order(self.id())).into()
     }
 
+    /// Check if this datatype is a complex number type (HDF5 2.0.0+).
+    #[cfg(feature = "2.0.0")]
+    pub fn is_complex(&self) -> bool {
+        h5lock!(H5Tget_class(self.id())) == H5T_class_t::H5T_COMPLEX
+    }
+
+    #[allow(unpredictable_function_pointer_comparisons)]
     pub fn conv_path<D>(&self, dst: D) -> Option<Conversion>
     where
         D: Borrow<Self>,
@@ -300,6 +307,11 @@ impl Datatype {
                     let base_dt = Self::from_id(H5Tget_super(id))?;
                     Ok(TD::VarLenArray(Box::new(base_dt.to_descriptor()?)))
                 }
+                // HDF5 2.0.0: Complex number datatype class
+                #[cfg(feature = "2.0.0")]
+                H5T_class_t::H5T_COMPLEX => {
+                    Err("Complex number datatypes are not yet supported in TypeDescriptor".into())
+                }
                 _ => Err("Unsupported datatype class".into()),
             }
         })
diff --git a/hdf5/src/hl/group.rs b/hdf5/src/hl/group.rs
index 098a7a04..e28bfa2a 100644
--- a/hdf5/src/hl/group.rs
+++ b/hdf5/src/hl/group.rs
@@ -621,9 +621,14 @@ pub mod tests {
             file.new_dataset::<u32>().no_chunk().shape((10, 20)).create("a/foo").unwrap();
             file.new_dataset::<u32>().no_chunk().shape((10, 20)).create("a/123").unwrap();
             file.new_dataset::<u32>().no_chunk().shape((10, 20)).create("a/bar").unwrap();
-            assert_eq!(group_a.member_names().unwrap(), vec!["123", "bar", "foo"]);
+            // Sort before comparing since iteration order may vary across HDF5 versions
+            let mut names_a = group_a.member_names().unwrap();
+            names_a.sort();
+            assert_eq!(names_a, vec!["123", "bar", "foo"]);
             assert_eq!(group_b.member_names().unwrap().len(), 0);
-            assert_eq!(file.member_names().unwrap(), vec!["a", "b"]);
+            let mut names_root = file.member_names().unwrap();
+            names_root.sort();
+            assert_eq!(names_root, vec!["a", "b"]);
         })
     }
 
diff --git a/hdf5/src/hl/location.rs b/hdf5/src/hl/location.rs
index 82adea4f..6e4d4fab 100644
--- a/hdf5/src/hl/location.rs
+++ b/hdf5/src/hl/location.rs
@@ -160,7 +160,7 @@ pub enum LocationType {
     Dataset,
     NamedDatatype,
     #[cfg(feature = "1.12.0")]
-    #[cfg_attr(docrs, doc(cfg(feature = "1.12.0")))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "1.12.0")))]
     TypeMap,
 }
 
diff --git a/hdf5/tests/dataset_test_utils.rs b/hdf5/tests/dataset_test_utils.rs
index b62177eb..a529d0ee 100644
--- a/hdf5/tests/dataset_test_utils.rs
+++ b/hdf5/tests/dataset_test_utils.rs
@@ -3,6 +3,8 @@
 //! This module provides helper functions, macros, and test fixtures
 //! to make testing dataset operations easier and more comprehensive.
 
+#![allow(unused_macros)]
+
 use hdf5::{File, Group, Result};
 use ndarray::Array2;
 use std::ops::Deref;
diff --git a/hdf5/tests/test_hdf5_2_0.rs b/hdf5/tests/test_hdf5_2_0.rs
new file mode 100644
index 00000000..0dfc2f0d
--- /dev/null
+++ b/hdf5/tests/test_hdf5_2_0.rs
@@ -0,0 +1,245 @@
+//! Tests for HDF5 2.0.0 features
+//!
+//! These tests are conditionally compiled when linking against HDF5 2.0.0 or later.
+
+mod common;
+
+use self::common::util::new_in_memory_file;
+
+/// Test that the H5T_COMPLEX datatype class is recognized (HDF5 2.0.0+)
+#[cfg(feature = "2.0.0")]
+mod hdf5_2_0_tests {
+    use super::*;
+
+    #[test]
+    fn test_is_complex_method_exists() {
+        // Test that is_complex() method is available on Datatype
+        let dt = hdf5::Datatype::from_type::<f32>().unwrap();
+        // A regular float should not be complex
+        assert!(!dt.is_complex());
+    }
+
+    #[test]
+    fn test_integer_not_complex() {
+        let dt = hdf5::Datatype::from_type::<i32>().unwrap();
+        assert!(!dt.is_complex());
+    }
+
+    #[test]
+    fn test_float_not_complex() {
+        let dt = hdf5::Datatype::from_type::<f64>().unwrap();
+        assert!(!dt.is_complex());
+    }
+
+    #[test]
+    fn test_h5t_class_t_has_complex_variant() {
+        // Verify that H5T_COMPLEX is available in the enum
+        use hdf5_sys::h5t::H5T_class_t;
+        let _complex = H5T_class_t::H5T_COMPLEX;
+        // H5T_NCLASSES should be 12 in HDF5 2.0.0+
+        assert_eq!(H5T_class_t::H5T_NCLASSES as i32, 12);
+    }
+
+    #[test]
+    fn test_complex_predefined_types_exist() {
+        // Test that the complex predefined types are available
+        use hdf5_sys::h5t::*;
+
+        // These should be accessible (they are extern statics)
+        // We just verify they exist by referencing them
+        let _ = *H5T_COMPLEX_IEEE_F32LE;
+        let _ = *H5T_COMPLEX_IEEE_F32BE;
+        let _ = *H5T_COMPLEX_IEEE_F64LE;
+        let _ = *H5T_COMPLEX_IEEE_F64BE;
+        let _ = *H5T_NATIVE_FLOAT_COMPLEX;
+        let _ = *H5T_NATIVE_DOUBLE_COMPLEX;
+    }
+
+    #[test]
+    fn test_bfloat16_predefined_types_exist() {
+        // Test that bfloat16 predefined types are available
+        use hdf5_sys::h5t::*;
+
+        let _ = *H5T_FLOAT_BFLOAT16LE;
+        let _ = *H5T_FLOAT_BFLOAT16BE;
+    }
+
+    #[test]
+    fn test_fp8_predefined_types_exist() {
+        // Test that FP8 predefined types are available
+        use hdf5_sys::h5t::*;
+
+        let _ = *H5T_FLOAT_F8E4M3;
+        let _ = *H5T_FLOAT_F8E5M2;
+    }
+
+    #[test]
+    fn test_h5tcomplex_create_exists() {
+        // Test that H5Tcomplex_create function is available
+        use hdf5_sys::h5t::H5Tcomplex_create;
+
+        // Just verify the function exists - we can't actually call it without a valid base type
+        let _fn_ptr: unsafe extern "C" fn(hdf5_sys::h5i::hid_t) -> hdf5_sys::h5i::hid_t =
+            H5Tcomplex_create;
+    }
+
+    #[test]
+    fn test_h5dread_chunk2_exists() {
+        // Test that H5Dread_chunk2 function is available
+        use hdf5_sys::h5d::H5Dread_chunk2;
+        use std::os::raw::c_void;
+
+        // Just verify the function exists
+        let _fn_ptr: unsafe extern "C" fn(
+            hdf5_sys::h5i::hid_t,
+            hdf5_sys::h5i::hid_t,
+            *const hdf5_sys::h5::hsize_t,
+            *mut u32,
+            *mut c_void,
+            *mut usize,
+        ) -> hdf5_sys::h5::herr_t = H5Dread_chunk2;
+    }
+
+    #[test]
+    fn test_h5tdecode2_exists() {
+        // Test that H5Tdecode2 function is available
+        use hdf5_sys::h5t::H5Tdecode2;
+        use std::os::raw::c_void;
+
+        // Just verify the function exists
+        let _fn_ptr: unsafe extern "C" fn(*const c_void, usize) -> hdf5_sys::h5i::hid_t =
+            H5Tdecode2;
+    }
+
+    #[test]
+    fn test_h5iregister_type2_exists() {
+        // Test that H5Iregister_type2 function is available
+        use hdf5_sys::h5i::{H5I_free_t, H5I_type_t, H5Iregister_type2};
+        use std::os::raw::c_uint;
+
+        // Just verify the function exists
+        let _fn_ptr: unsafe extern "C" fn(c_uint, H5I_free_t) -> H5I_type_t = H5Iregister_type2;
+    }
+
+    #[test]
+    fn test_basic_file_operations_work_on_2_0() {
+        // Ensure basic HDF5 operations still work with 2.0
+        let file = new_in_memory_file().unwrap();
+
+        // Create a group
+        let group = file.create_group("test_group").unwrap();
+        assert!(group.name() == "/test_group");
+
+        // Create a dataset
+        let ds = file.new_dataset::<i32>().shape([10, 10]).create("test_ds").unwrap();
+        assert_eq!(ds.shape(), vec![10, 10]);
+
+        // Write and read data
+        let data: Vec<i32> = (0..100).collect();
+        let arr = ndarray::Array::from_shape_vec((10, 10), data).unwrap();
+        ds.write(&arr).unwrap();
+
+        let read_arr: ndarray::Array2<i32> = ds.read().unwrap();
+        assert_eq!(arr, read_arr);
+    }
+
+    #[test]
+    fn test_datatype_operations_work_on_2_0() {
+        // Test datatype operations on HDF5 2.0
+        let dt_i32 = hdf5::Datatype::from_type::<i32>().unwrap();
+        let dt_f64 = hdf5::Datatype::from_type::<f64>().unwrap();
+
+        // Basic operations should work
+        assert_eq!(dt_i32.size(), 4);
+        assert_eq!(dt_f64.size(), 8);
+
+        // Conversion checks should work
+        assert!(dt_i32.is::<i32>());
+        assert!(!dt_i32.is::<f64>());
+    }
+}
+
+/// Tests that should work on all HDF5 versions
+#[cfg(not(feature = "2.0.0"))]
+mod pre_hdf5_2_0_tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[test]
+    fn test_h5t_class_t_without_complex() {
+        // Verify that H5T_NCLASSES is 11 in pre-2.0 HDF5
+        use hdf5_sys::h5t::H5T_class_t;
+        assert_eq!(H5T_class_t::H5T_NCLASSES as i32, 11);
+    }
+
+    #[test]
+    fn test_h5dread_chunk_exists() {
+        // Test that the original H5Dread_chunk function is available
+        #[cfg(feature = "1.10.3")]
+        {
+            use hdf5_sys::h5d::H5Dread_chunk;
+            use std::os::raw::c_void;
+
+            let _fn_ptr: unsafe extern "C" fn(
+                hdf5_sys::h5i::hid_t,
+                hdf5_sys::h5i::hid_t,
+                *const hdf5_sys::h5::hsize_t,
+                *mut u32,
+                *mut c_void,
+            ) -> hdf5_sys::h5::herr_t = H5Dread_chunk;
+        }
+    }
+
+    #[test]
+    fn test_h5tdecode_exists() {
+        // Test that the original H5Tdecode function is available
+        use hdf5_sys::h5t::H5Tdecode;
+        use std::os::raw::c_void;
+
+        let _fn_ptr: unsafe extern "C" fn(*const c_void) -> hdf5_sys::h5i::hid_t = H5Tdecode;
+    }
+
+    #[test]
+    fn test_h5iregister_type_exists() {
+        // Test that the original H5Iregister_type function is available
+        use hdf5_sys::h5i::{H5I_free_t, H5I_type_t, H5Iregister_type};
+        use std::os::raw::c_uint;
+
+        let _fn_ptr: unsafe extern "C" fn(usize, c_uint, H5I_free_t) -> H5I_type_t =
+            H5Iregister_type;
+    }
+}
+
+/// Version-agnostic tests
+mod version_agnostic_tests {
+    use super::*;
+
+    #[test]
+    fn test_basic_roundtrip() {
+        let file = new_in_memory_file().unwrap();
+        let ds = file.new_dataset::<f64>().shape([5]).create("data").unwrap();
+
+        let data = ndarray::arr1(&[1.0, 2.0, 3.0, 4.0, 5.0]);
+        ds.write(&data).unwrap();
+
+        let read_data: ndarray::Array1<f64> = ds.read().unwrap();
+        assert_eq!(data, read_data);
+    }
+
+    #[test]
+    fn test_datatype_descriptor_roundtrip() {
+        use hdf5::H5Type;
+
+        #[derive(H5Type)]
+        #[repr(C)]
+        struct TestStruct {
+            x: i32,
+            y: f64,
+        }
+
+        let dt = hdf5::Datatype::from_type::<TestStruct>().unwrap();
+        let desc = dt.to_descriptor().unwrap();
+        let dt2 = hdf5::Datatype::from_descriptor(&desc).unwrap();
+        assert_eq!(dt, dt2);
+    }
+}