v0.0.1 — Open Source & Free

The Time-Series Database
Built for Solar

Purpose-built TSDB for solar energy monitoring — pre-computed aggregation across 4 levels, columnar storage optimized for irradiance & power metrics, and sub-100ms queries at scale. Built in Go for solar farms, inverters, and real-time energy analytics.

Get StartedView on GitHub
$git clone https://github.com/soltixdb/soltix.git
10K+
Metrics/sec
<100ms
Query latency
4-Level
Pre-Aggregation
Solar
Optimized

Why Soltix?

Soltix is purpose-built for solar plant monitoring — a domain where every installation is physically fixed at a single geographic location with a permanent timezone.

Traditional TSDB
  • ✗Re-aggregate at every query request
  • ✗High query latency at scale
  • ✗Complex query language required
  • ✗Heavy resource usage for analytics
Soltix
  • ✓Pre-computed aggregates — zero re-aggregation
  • ✓Sub-100ms queries at any scale
  • ✓Simple REST API — no query language needed
  • ✓5 adaptive encoders — Gorilla, Delta, Dictionary, Bitmap & Snappy
⚡

Zero Re-aggregation

Hourly, daily, monthly, yearly rollups pre-computed at write time — queries read directly

📁

Adaptive Compression

Gorilla XOR for floats, Delta-Zigzag for timestamps, Dictionary for strings, Bitmap for bools, Snappy at block level

🔀

Distributed by Design

Hash-based sharding, replication, and MapReduce queries across nodes

🚀

Simple REST API

Write and query with standard HTTP — no proprietary query language needed

Everything you need for time-series data

From high-speed ingestion to advanced analytics — Soltix has it all built-in.

Core Capabilities

High Performance

10K+ writes/sec with sub-100ms query latency using memory cache and columnar storage.

Multi-Level Aggregation

Pre-computed 1h / 1d / 1mo / 1y aggregates for instant analytics without re-computation.

Horizontal Scalability

Add storage nodes to scale linearly. Consistent hashing ensures even data distribution.

Efficient Storage

Columnar format with 5 adaptive encoders (Gorilla, Delta, Dictionary, Bitmap, Snappy) and 3-tier group architecture.

Advanced Analytics

Anomaly Detection

Built-in Z-Score, IQR, and Moving Average algorithms with automatic detection.

Forecasting

SMA, Holt-Winters, ARIMA, Prophet-style, and ML-based prediction models.

Downsampling

LTTB, MinMax, Average, M4 algorithms for efficient large dataset visualization.

Streaming Queries

Server-Sent Events (SSE) for real-time large dataset streaming.

Infrastructure

WAL + Batching

Write-ahead log for durability with batch flush for maximum write throughput.

Multi-Queue Support

Flexible message queue backends — NATS, Redis Streams, or Kafka.

MapReduce Queries

Parallel query execution across shards with automatic result aggregation.

API Authentication

API key auth with X-API-Key header or Bearer token support.

Built for Every Time-Series Workload

From solar farms to smart factories — Soltix handles any time-series data at scale.

Solar & Renewable Energy

Monitor inverter output, panel efficiency, and energy yield. Pre-computed daily and monthly aggregates make production reports instant.

Power outputIrradianceYield tracking

Smart Factory & IIoT

Track machine vibration, temperature, pressure, and throughput across production lines. Pre-computed aggregation makes shift reports and OEE dashboards instant.

Machine healthOEE metricsPredictive maintenance

IoT Sensor Networks

Ingest data from thousands of sensors — temperature, humidity, motion, air quality. Designed for high-cardinality device IDs at scale.

EnvironmentalSmart buildingAgriculture

Energy & Utilities

Monitor power grids, water systems, and gas pipelines. Pre-computed aggregation delivers instant daily consumption reports and trend analysis.

Smart metersGrid monitoringConsumption

Distributed Architecture

Router + Storage separation with message queues for reliable, horizontally scalable deployments.

┌──────────────────────────────────────────────────┐
│              Client Applications                 │
│         (REST API / SSE / Downloads)             │
└────────────────────┬─────────────────────────────┘
                     │ HTTP
                     ▼
┌──────────────────────────────────────────────────┐
│            Router Service (HTTP API)             │
│  ┌────────────────────────────────────────────┐  │
│  │  ShardRouter + QueryCoordinator            │  │
│  │  • Consistent hashing (Rendezvous)         │  │
│  │  • MapReduce parallel queries              │  │
│  │  • Anomaly Detection + Forecasting         │  │
│  │  • Streaming (SSE) + Downsampling          │  │
│  └────────────────────────────────────────────┘  │
└────────────────────┬─────────────────────────────┘
                     │
           ┌─────────┴───────────┐
           │  Message Queue      │
           │  (NATS/Redis/Kafka) │
           └─────────┬───────────┘
                     │
        ┌────────────┼────────────┐
        │            │            │
        ▼            ▼            ▼
  ┌───────────┐┌───────────┐┌───────────┐
  │ Storage-1 ││ Storage-2 ││ Storage-3 │
  │ Group 0-2 ││ Group 3-5 ││ Group 6-8 │
  │ gRPC Srv  ││ gRPC Srv  ││ gRPC Srv  │
  └─────┬─────┘└─────┬─────┘└─────┬─────┘
        │            │            │
    ┌───┴───┐    ┌───┴───┐    ┌───┴───┐
    │ Mem   │    │ Mem   │    │ Mem   │
    │  WAL  │    │  WAL  │    │  WAL  │
    │  Disk │    │  Disk │    │  Disk │
    └───────┘    └───────┘    └───────┘

Router Layer

HTTP REST API gateway with query coordination, hash-based routing, and built-in analytics.

Message Queue

Decoupled write path via NATS, Redis Streams, or Kafka for reliable data delivery.

Storage Layer

3-tier engine: Group → Device Group → Partition with columnar format and WAL.

Built for Performance

Optimized at every layer — from memory cache to columnar disk format.

Benchmark Results

Write Throughput10,000+ points/sec
Query Latency (raw)<100 ms
Query Latency (aggregated)<10 ms
Compression Ratio3-5x reduction
1h
Pre-computed
1d
Pre-computed
1mo
Pre-computed
1y
Pre-computed

Simple REST API

Ingest data with a single POST. Query with intuitive parameters. No query language to learn.

POSTWrite data points
# Write a data point
curl -X POST http://localhost:5555/v1/write \
  -H "Content-Type: application/json" \
  -d '{
    "database": "factory_01",
    "collection": "sensors",
    "points": [{
      "id": "sensor-A1",
      "timestamp": "2026-02-15T10:30:00+09:00",
      "fields": {
        "temperature": 42.1,
        "humidity": 65.3,
        "pressure": 1013.25
      }
    }]
  }'
GETQuery data with aggregation
# Query hourly aggregation
curl http://localhost:5555/v1/query \
  -G \
  -d database=factory_01 \
  -d collection=sensors \
  -d interval=1h \
  -d start=2026-02-15T00:00:00+09:00 \
  -d end=2026-02-15T23:59:59+09:00

# Response (pre-computed — zero re-aggregation)
{
  "data": [{
    "time": "2026-02-15T10:00:00+09:00",
    "device_id": "sensor-A1",
    "temperature": { "avg": 41.8, "min": 39.0, "max": 45.0, "count": 60 },
    "humidity": { "avg": 64.5, "min": 58.2, "max": 70.1, "count": 60 }
  }]
}
YAMLSimple configuration
# configs/config.yaml
storage:
  timezone: "Asia/Tokyo"   # Timezone for aggregation boundaries
  data_dir: "./data"
  compression: "adaptive"  # Gorilla|Delta|Dictionary|Bitmap|Snappy

aggregation:
  levels: ["1h", "1d", "1mo", "1y"]  # Pre-compute all 4 levels

Get Started in Minutes

From clone to first query in under 5 minutes. No complex setup, no external dependencies beyond etcd.

1

Clone & Build

git clone https://github.com/soltixdb/soltix.git
cd soltix
make build
2

Start Infrastructure

# Start etcd + NATS
docker-compose up -d etcd nats
3

Run Services

# Start storage node
./bin/storage -config configs/config.yaml

# Start router (in another terminal)
./bin/router -config configs/config.yaml
4

Write & Query

# Write data
curl -X POST http://localhost:5555/v1/write \
  -H "Content-Type: application/json" \
  -d '{"database":"mydb","collection":"sensors","points":[...]}'

# Query data
curl http://localhost:5555/v1/query?database=mydb&collection=sensors

Prerequisites

🔧Go 1.25+
🗄️etcd 3.5+
📨NATS / Redis / Kafka