Cloud Parts

Arc

A young single-binary time-series database in Go that writes incoming data as Parquet files and queries them with DuckDB SQL.

What it is
Time-series databases
Type
Open source
Made by
Basekick Labs
License
AGPL-3.0 (Arc OSS); Arc Enterprise features ship in the same binary and are unlocked by a commercial licence key
Facts checked
6 October 2026
Website Source code

What it is

Arc is one Go binary with DuckDB compiled in. Clients send data over HTTP as InfluxDB line protocol (so Telegraf and other InfluxDB writers work unchanged), as columnar MessagePack, or through an MQTT subscription. Arc buffers rows in memory, with an optional write-ahead log, and flushes them about every 5 seconds as Parquet files laid out by database, measurement and hour, on local disk, S3 or an S3-compatible store, or Azure Blob. A background job merges each hour’s small files into one, then each day’s into one, dropping duplicate rows when the measurement has tags. Queries are SQL sent to an HTTP endpoint: Arc picks the partitions in the time range and hands them to DuckDB, returning JSON, MessagePack or Arrow. Since 26.09.1 it can also register its Parquet files as Apache Iceberg tables, so Spark or Trino read the same files.

The open-source build is AGPL-3.0. Basekick Labs sells Arc Enterprise, which uses a licence key to switch on clustering with writer, reader and compactor roles and automatic failover, role-based access control with SSO, hot/cold tiering, scheduled continuous queries and retention, and query quotas. On 2026-10-06 it was listed at $5,000 a year for up to 8 cores, $15,000 for up to 32 cores and $40,000 for up to 128 cores, billed annually. Arc Cloud launched in April 2026 with plans from $50 a month; Basekick’s managed page now offers Arc Enterprise Managed on dedicated servers, priced per agreement. The first commit was on October 7, 2025, so Arc is a year old, with 16 releases on GitHub so far.

Why teams pick it

  • Data stays in open Parquet files on your own disk or bucket, readable by DuckDB, Spark or any Parquet tool, and since 26.09.1 also as Iceberg tables
  • Drop-in ingestion for InfluxDB setups: line protocol endpoints compatible with InfluxDB 1.x and 2.x, a Telegraf output plugin, and tsm2arc to import InfluxDB’s files from disk
  • One binary with no external services: a laptop, an edge box or a Kubernetes pod via the Helm chart, with an optional FIPS 140-3 build
  • Full DuckDB SQL (joins, window functions, CTEs) over current and historical data in one query
  • AGPL-3.0 from the first public release, with the licence and the commercial option stated up front

Watch out for

  • Young: first commit October 2025, rewritten from Python to Go within two months, and recent patch releases still fix clustering and data-loss bugs, such as a shutdown path in 26.09.2 that could drop acknowledged writes during a storage outage
  • Open core: clustering, failover, RBAC, tiering, and scheduled retention and continuous queries need Arc Enterprise; in the open build, retention policies and continuous queries run only when you trigger them
  • AGPL-3.0: changes you distribute or offer as a network service must be published, which some companies’ policies rule out, so they need the commercial licence
  • Headline numbers are Basekick’s own: 34 million records a second was measured on a MacBook Pro, and its first ClickBench submission in October 2025 was rerun after ClickBench maintainers flagged cache flushing, leaving cold runs about three times slower
  • The engine may change: Basekick plans ArcX, a proprietary query engine meant to replace DuckDB in Arc

Alternatives

What all time-series databases have in common →
Amazon TimestreamAWSAWS’s time-series databases: a serverless engine now closed to new customers, and managed InfluxDB 2 and 3.Apache IoTDBOpen sourceAn Apache time-series database for industrial IoT that stores everything in its own open file format, TsFile, and lets you model devices as a tree of paths or as SQL tables.+1 TimechoDBArcticDBCommercialMan Group’s serverless DataFrame database: a Python library with a C++ engine that stores versioned pandas DataFrames directly in S3, Azure Blob Storage or local LMDB.GreptimeDBOpen sourceA Rust database that stores metrics, logs and traces as tables on object storage, queried with SQL or PromQL.InfluxDBOpen sourceThe best-known time-series database, fed by line protocol and Telegraf; now in its third generation, a Rust rewrite that keeps data as Parquet files on object storage.kdb+CommercialA columnar time-series database that is also an interpreter for q, an array language, used for market data across trading and risk.QuestDBOpen sourceA columnar time-series database in Java, C++ and Rust that ingests millions of rows a second and answers time-series SQL, with old partitions kept as Parquet.TDengineOpen sourceA clustered time-series database for IoT and industrial data that gives every device its own table, grouped under “supertables” with tags.TimescaleDBOpen sourceA PostgreSQL extension that turns ordinary tables into time-partitioned, compressed time-series tables.Workers Analytics EngineCommercialCloudflare’s time-series analytics store for Workers: a non-blocking `writeDataPoint()` call to record events with unlimited cardinality, adaptive sampling to keep it cheap, and a SQL API to query them.

How it fits with other technologies

Write line protocol, then query it with SQL · bash

ARC=http://localhost:8000

# two readings in InfluxDB line protocol (nanosecond timestamps)
curl -X POST "$ARC/api/v1/write/line-protocol" \
  -H "Authorization: Bearer $ARC_TOKEN" \
  -H "x-arc-database: plant" \
  -H "Content-Type: text/plain" \
  --data-binary $'pressure,well=w17,site=north psi=812.5 1791273600000000000\npressure,well=w18,site=north psi=790.1 1791273600000000000'

# buffered rows are flushed to Parquet every 5 s by default; then query with DuckDB SQL
curl -X POST "$ARC/api/v1/query" \
  -H "Authorization: Bearer $ARC_TOKEN" \
  -H "x-arc-database: plant" \
  -H "Content-Type: application/json" \
  --data-binary @- <<'EOF'
{"sql": "SELECT well, date_trunc('hour', time) AS hour, max(psi) AS peak_psi FROM pressure WHERE time > now() - INTERVAL 1 DAY GROUP BY well, hour ORDER BY hour"}
EOF

Arc OSS, Enterprise and Managed#

The same binary in every column; a licence key unlocks the Enterprise features. Prices are list prices checked on 2026-10-06.

FeatureArc OSSArc EnterpriseArc Enterprise Managed
Who runs itYouYouBasekick Labs, on dedicated servers in six locations
LicenceAGPL-3.0CommercialCommercial
PriceFree$5,000 a year (8 cores, 1 machine), $15,000 (32 cores, 5 machines), $40,000 (128 cores), or customPer agreement, fixed monthly price on a 1- or 3-year term
Ingestion, Parquet storage, compaction, SQL, S3 and AzureYesYesYes
Clustering, automatic failover, writer/reader/compactor rolesNo, single nodeYes, 3 or more nodesYes
Retention policies and continuous queriesRun when you trigger themScheduledScheduled
RBAC, LDAP/SAML/OIDC, audit log, query quotas, hot/cold tieringNo; token authentication onlyYesYes
  • When an Enterprise key expires (after a 14-day grace period), Arc falls back to OSS behaviour: ingestion, queries and compaction keep working, while clustering, RBAC and tiering switch off.
  • Enterprise licences are tied to machine fingerprints and validated locally, so air-gapped sites can activate them offline.

See it in a real stack

No architecture uses Arc yet. Drop it into the playground and wire it up yourself.Open playground →

Benchmarks

Benchmark · ClickHouse Inc.ClickBenchHow fast analytical databases run 43 SQL queries over one 100-million-row table of web analytics events, on the same cloud machines.Includes Arc · 7 caveats to read first
How to read a benchmark →
Where it came from2022–2026

Ignacio Van Droogenbroeck, a former InfluxData employee, started in November 2022 with a side project: an API to deploy hosted time-series databases on several clouds. By 2023 he ran it full time, hosting InfluxDB, TimescaleDB and QuestDB for customers, mostly in Latin America, and wanted a database of his own. A first attempt, Wavestream, managed about 20,000 writes a second and ended in 2024.

He started again with Historian, a tiered-storage add-on that copied InfluxDB 1.x and 2.x data into Parquet files on S3 and used DuckDB to query them. Sold to InfluxDB Enterprise customers with scaling problems, it gradually grew into a database, which Basekick Labs, based in Costa Rica, published as Arc in October 2025 under AGPL-3.0.

The first version was written in Python to test demand quickly. After memory leaks in its multi-worker design, Basekick rewrote all 18,280 lines in Go for release 25.12.1, shipped at the end of November 2025. Enterprise clustering, a managed cloud and Iceberg tables followed in 2026.

Why it’s built this way

Plain Parquet files instead of a private storage format
Historian had already shown that time-series data could live as Parquet on S3, and open files mean customers can query or leave with their data without Arc.
DuckDB as the query engine
Rather than write a SQL engine, Basekick built on DuckDB, which had started as Historian’s way to run SQL over Parquet files.
AGPL-3.0 from day one
Van Droogenbroeck had watched Redis, Elastic and MinIO change licences after cloud providers resold their work, and wanted the rules and the commercial licence stated before anyone depended on Arc.
Compaction in a separate subprocess
DuckDB’s memory allocator keeps memory after each job, so long-running compaction bloated the server; a child process returns everything to the OS when it exits and can’t crash the API.

Timeline

  1. 2022

    Side project to host time-series databases begins in November

  2. 2024

    First prototype, Wavestream, is abandoned; work on Historian begins

  3. 2025

    Arc published under AGPL-3.0 in October; Go rewrite ships in November

  4. 2026

    Arc Cloud in April; quarterly releases from June; Iceberg in September

Sources16 · facts checked 6 October 2026

Improve this page on GitHub