Extension Availability for DuckDB Versions

DuckDB extensions provide additional functionality but aren’t available for all versions and platforms. This webpage was created to simplify determining which extensions are available for specific versions of DuckDB, as tracking compatibility across different releases can be complex.

Here’s what affects extension availability:

Version Compatibility

Extensions are typically built for the current DuckDB version (1.3). However:

• Legacy Extensions: Some extensions were released for older versions and haven’t been updated by their maintainers
• New Extensions: Newer extensions may only be available for recent versions
• Retired Extensions: Some extensions are no longer maintained or have been retired
• Compatibility Updates Needed: Extensions may become incompatible with newer DuckDB versions and require maintainer updates

When upgrading DuckDB, check that required extensions are available for your target version.

Platform Support

Extensions are compiled for specific platforms. DuckDB supports:

Native Platforms:

• linux_amd64_musl - Alpine/musl Linux x86_64
• linux_amd64 - Standard Linux x86_64
• linux_arm64 - Linux ARM64
• osx_amd64 - macOS Intel
• osx_arm64 - macOS Apple Silicon
• windows_amd64_mingq - Windows x86_66 Mingw
• windows_amd64 - Windows x86_64

WebAssembly:

• wasm_mvp - Basic WASM
• wasm_eh - WASM with exception handling
• wasm_threads - WASM with threading

Extensions compiled for one platform won’t work on others. WebAssembly platforms typically have fewer available extensions due to browser environment limitations.

Why Extensions May Be Unavailable

• Platform Dependencies: Extension requires libraries not available on all platforms
• Compilation Issues: Technical challenges building for specific platforms
• Maintenance: Extension no longer actively maintained for newer versions
• Licensing: Distribution restrictions on certain platforms
• Experimental Status: Only available in development builds

Best Practices

• Verify extension availability before depending on it in production
• Plan fallback strategies for critical functionality
• Check compatibility when upgrading DuckDB versions
• Monitor extension status between releases

---

Last updated: July 10, 2025

Report Parameters

// Create filters
viewof selected_extensions = Inputs.select(
  extension_names,
  {
    label: "Select Extensions:",
    multiple: true,
    value: extension_names,
    className: "form-select"
  }
)

viewof selected_versions = Inputs.checkbox(
  version_list,
  {
    label: "Select DuckDB Versions:",
    multiple: true,
        className: "form-select form-select-lg",

    value: version_list  // Default to latest 2 versions
  }
)

viewof selected_platforms = Inputs.select(
  platform_list,
  {
    label: "Select Platforms:",
    multiple: true,
        className: "form-select",

    value: platform_list
  }
)

---

filtered_data = extensions_data.filter(d =>
  selected_extensions.includes(d["Extension Name"]) &&
  selected_versions.includes(d.Version) &&
  selected_platforms.includes(d.Platform)
)
// Smart pivot table that chooses optimal layout
smart_pivot = {
  const ext_count = selected_extensions.length;
  const platform_count = selected_platforms.length;
  const version_count = selected_versions.length;

  // Decision logic: if we have more platforms than extensions, group by platform first
  const group_by_platform_first = platform_count > ext_count;

  const result = [];

  if (group_by_platform_first) {
    // Group by Platform, then Extension
    const grouped = d3.group(filtered_data, d => d.Platform, d => d["Extension Name"]);

    for (const [platform, extensionMap] of grouped) {
      for (const [extension, records] of extensionMap) {
        const row = {
          "Primary": platform,
          "Secondary": extension,
          "Type": "Platform → Extension"
        };

        // Add version columns
        for (const version of selected_versions) {
          const record = records.find(r => r.Version === version);
          row[version] = record ? record.Available : false;
        }
        result.push(row);
      }
    }
  } else {
    // Group by Extension, then Platform
    const grouped = d3.group(filtered_data, d => d["Extension Name"], d => d.Platform);

    for (const [extension, platformMap] of grouped) {
      for (const [platform, records] of platformMap) {
        const row = {
          "Primary": extension,
          "Secondary": platform,
          "Type": "Extension → Platform"
        };

        // Add version columns
        for (const version of selected_versions) {
          const record = records.find(r => r.Version === version);
          row[version] = record ? record.Available : false;
        }
        result.push(row);
      }
    }
  }

  return result.sort((a, b) => a.Primary.localeCompare(b.Primary) || a.Secondary.localeCompare(b.Secondary));
}
// Create table columns dynamically
table_columns = ["Primary", "Secondary", ...selected_versions]

// Dynamic headers based on current grouping
table_headers = {
  const sample_row = smart_pivot[0];
  if (!sample_row) return {};

  const is_platform_first = sample_row.Type === "Platform → Extension";

  return {
    "Primary": is_platform_first ? "Platform" : "Extension",
    "Secondary": is_platform_first ? "Extension" : "Platform",
    ...Object.fromEntries(selected_versions.map(v => [v, `v${v}`]))
  };
}
// Create separate tables for each extension (caniuse style)
extension_tables = {
  const tables = [];

  for (const extension of selected_extensions) {
    // Filter data for this specific extension
    const extension_data = filtered_data.filter(d => d["Extension Name"] === extension);

    // Create pivot table: platforms as rows, versions as columns
    const platform_rows = [];

    for (const platform of selected_platforms) {
      const row = { "Platform": platform };

      // Add availability for each version
      for (const version of selected_versions) {
        const record = extension_data.find(d =>
          d.Platform === platform && d.Version === version
        );
        row[version] = record ? record.Available : false;
      }

      platform_rows.push(row);
    }

    tables.push({
      extension: extension,
      data: platform_rows,
      total_available: extension_data.filter(d => d.Available).length,
      total_combinations: selected_platforms.length * selected_versions.length
    });
  }

  return tables;
}
// Display each extension table
html`${extension_tables.map(table => {
  const availability_rate = table.total_combinations > 0 ?
    (table.total_available / table.total_combinations * 100).toFixed(1) : 0;

  return html`
    <div style="margin-bottom: 2rem; border: 1px solid #e1e5e9; border-radius: 8px; padding: 1rem;">
      <h3 style="margin-top: 0; color: #24292f; display: flex; align-items: center; gap: 0.5rem;">
        <span style="font-family: monospace; background: #f6f8fa; padding: 0.25rem 0.5rem; border-radius: 4px;">
          ${table.extension}
        </span>
      </h3>

      ${Inputs.table(table.data, {
        columns: ["Platform", ...selected_versions],
        select: null,
        multiple: false,
        header: {
          "Platform": "Platform",
          ...Object.fromEntries(selected_versions.map(v => [v, `${v}`]))
        },
        format: {
          "Platform": x => html`<span style="font-family: monospace;">${x}</span>`,
          ...Object.fromEntries(
            selected_versions.map(version => [
              version,
              x => x ? html`<span style="color: #1a7f37; font-weight: bold;">✅</span>` :
                       html`<span style="color: #d1242f; font-weight: bold;">❌</span>`
            ])
          )
        },
        width: {
          Platform: 140
        }
      })}
    </div>
  `;
})}`

Do you ❤️ DuckDB extensions? You’ll Love This.

Get the best from Query.Farm — smart tips, powerful tools, and project updates sent directly to your inbox, but only when we’ve got something great to share.