HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
timescale
timescaledb
C2017–2026
timescale / timescaledb

timescaledb

A time-series database for high-performance real-time analytics packaged as a Postgres extension

46Distinct people
71Mentions
0Explicit recommenders
23.9KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

A time-series database for high-performance real-time analytics packaged as a Postgres extension

GitHub

Where it is used

  • Titan America — Titan America runs Tiger Cloud with multiple services that run TimescaleDB to ingest and store its sensor data. TimescaleDB serves as the operational engine for their time-series workloads in the deployment. Source
  • Tiger Data — “But we took a different, heretical route: we decided to build TimescaleDB on top of Postgres, a 20-year-old, seemingly boring database.” Source
  • 2 more documented examples

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 12:01:57 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year71 dated mentions

Observed mentions: 2017-04-04 18:28:40 UTC to 2026-06-15 19:27:40 UTC.

051015202017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 6 mentions; 0 submissions, 6 comments20172018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 10 mentions; 1 submissions, 9 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 7 mentions; 0 submissions, 7 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 20 mentions; 0 submissions, 20 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 7 mentions; 0 submissions, 7 comments20212022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 8 mentions; 0 submissions, 8 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 7 mentions; 2 submissions, 5 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC606
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC1019
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC707
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC20020
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC707
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC808
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC202
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC725
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC202
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC202

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
TimescaleDB is a PostgreSQL extension for high-performance real-time analytics on time-series and event data Quick Start with TimescaleDB Get started with TimescaleDB in under 10 minutes. This guide will help you run TimescaleDB locally, create your first hypertable with columnstore enabled, write data to the columnstore, and see instant analytical query performance. What You'll Learn How to run TimescaleDB with a one-line install or Docker command How to create a hypertable with columnstore enabled How to insert data directly to the columnstore How to execute analytical queries Prerequisites Docker installed on your machine 8GB RAM recommended psql client (included with PostgreSQL) or any PostgreSQL client like pgAdmin Step 1: Start TimescaleDB You have two options to start TimescaleDB: Option 1: One-line install (Recommended) The easiest way to get started: Important: This script is intended for local development and testing only. Do not use it for production deployments. For production-ready installation options, see the TimescaleDB installation guide. Linux/Mac: curl -sL https://tsdb.co/start-local | sh This command: Downloads and starts TimescaleDB (if not already downloaded) Exposes PostgreSQL on port 6543 (a non-standard port to avoid conflicts with other PostgreSQL instances on port 5432) Automatically tunes settings for your environment using timescaledb-tune Sets up a persistent data volume Option 2: Manual Docker command also used for Windows Alternatively, you can run TimescaleDB directly with Docker: docker run -d --name timescaledb \ -p 6543:5432 \ -e POSTGRES_PASSWORD=password \ timescale/timescaledb-ha:pg18 Note: We use port 6543 (mapped to container port 5432) to avoid conflicts if you have other PostgreSQL instances running on the standard port 5432. Wait about 1-2 minutes for TimescaleDB to download & initialize. Step 2: Connect to TimescaleDB Connect using psql: psql -h localhost -p 6543 -U postgres # When prompted, enter password: password You should see the PostgreSQL prompt. Verify TimescaleDB is installed: SELECT extname, extversion FROM pg_extension WHERE extname = 'timescaledb'; Expected output: extname | extversion -------------+------------ timescaledb | 2.x.x Prefer a GUI? If you'd rather use a graphical tool instead of the command line, you can download pgAdmin and connect to TimescaleDB using the same connection details (host: localhost, port: 6543, user: postgres, password: password). Step 3: Create Your First Hypertable Let's create a hypertable for IoT sensor data with columnstore enabled: -- Create a hypertable with automatic columnstore CREATE TABLE sensor_data ( time TIMESTAMPTZ NOT NULL, sensor_id TEXT NOT NULL, temperature DOUBLE PRECISION, humidity DOUBLE PRECISION, pressure DOUBLE PRECISION ) WITH ( tsdb.hypertable ); tsdb.hypertable - Converts this into a TimescaleDB hypertable See more: About hypertables API reference About columnstore Enable columnstore manually API reference Step 4: Insert Sample Data Let's add some sample sensor readings: -- Enable timing to see time to execute queries \timing on -- Insert sample data for multiple sensors -- SET timescaledb.enable_direct_compress_insert = on to insert data directly to the columnstore (columnnar format for performance) SET timescaledb.enable_direct_compress_insert = on; INSERT INTO sensor_data (time, sensor_id, temperature, humidity, pressure) SELECT time, 'sensor_' || ((random() * 9)::int + 1), 20 + (random() * 15), 40 + (random() * 30), 1000 + (random() * 50) FROM generate_series( NOW() - INTERVAL '90 days', NOW(), INTERVAL '1 seconds' ) AS time; -- Once data is inserted into the columnstore we optimize the order and structure -- this compacts and orders the data in the chunks for optimal query performance and compression DO $$ DECLARE ch TEXT; BEGIN FOR ch IN SELECT show_chunks('sensor_data') LOOP CALL convert_to_columnstore(ch, recompress := true); END LOOP; END $$; This generates ~7,776,001 readings across 10 sensors over the past 90 days. Verify the data was inserted: SELECT COUNT(*) FROM sensor_data; Step 5: Run Your First Analytical Queries Now let's run some analytical queries that showcase TimescaleDB's performance: -- Enable query timing to see performance \timing on -- Query 1: Average readings per sensor over the last 7 days SELECT sensor_id, COUNT(*) as readings, ROUND(AVG(temperature)::numeric, 2) as avg_temp, ROUND(AVG(humidity)::numeric, 2) as avg_humidity, ROUND(AVG(pressure)::numeric, 2) as avg_pressure FROM sensor_data WHERE time > NOW() - INTERVAL '7 days' GROUP BY sensor_id ORDER BY sensor_id; -- Query 2: Hourly averages using time_bucket -- Time buckets enable you to aggregate data in hypertables by time interval and calculate summary values. SELECT time_bucket('1 hour', time) AS hour, sensor_id, ROUND(AVG(temperature)::numeric, 2) as avg_temp, ROUND(AVG(humidity)::numeric, 2) as avg_humidity FROM sensor_data WHERE time > NOW() - INTERVAL '24 hours' GROUP BY hour, sensor_id ORDER BY hour DESC, sensor_id LIMIT 20; -- Query 3: Daily statistics across all sensors SELECT time_bucket('1 day', time) AS day, COUNT(*) as total_readings, ROUND(AVG(temperature)::numeric, 2) as avg_temp, ROUND(MIN(temperature)::numeric, 2) as min_temp, ROUND(MAX(temperature)::numeric, 2) as max_temp FROM sensor_data GROUP BY day ORDER BY day DESC LIMIT 10; -- Query 4: Latest reading for each sensor -- Highlights the value of Skipscan executing in under 100ms without skipscan it takes over 5sec SELECT DISTINCT ON (sensor_id) sensor_id, time, ROUND(temperature::numeric, 2) as temperature, ROUND(humidity::numeric, 2) as humidity, ROUND(pressure::numeric, 2) as pressure FROM sensor_data ORDER BY sensor_id, time DESC; Notice how fast these analytical queries run, even with aggregations across millions of rows. This is
Read the full README on GitHub

What Hacker News says

8 sources
I do want to note Timescale's license is extremely generous: https://github.com/timescale/timescaledb/blob/main/tsl/LICEN... There's a marked difference between what they allow you vs Mongo (SSPL) and Elastic (Elastic license) -- see (b). Also generally the Postgres ecosystem has in general seemingly found a way to strike a balance between creating immense value (point to a F/OSS DB that's better than Postgres) and enabling commercial success (Citus, 2nd Quadrant, EDB, Timescale, Supabase, Neon are all very successful) I do agree with the overall trend though -- I already think the future is going to be AGPL[0] (but that's based partially on a misunderstanding of what AGPL does). It remains to be seen if people will cynically make projects open source to start and then switch to something like SSPL/BSL/Elastic later, but the unintentional
Read the rest
rug pulls will probably continue for a while. [0]: https://vadosware.io/post/the-future-of-free-and-open-source...
In The Dead End
(NB - blog author/Timescale employee) One thing we're improving as we move forward in documentation and other areas is explaining why doing joins (and things like window functions) is difficult in continuous aggregates and not the current focus. Honestly, it's part of the reason most databases haven't tackled this problem before. Once you add in joins or things that might refer to data outside of the refresh window (LAG values for example), things get really complicated. For instance, if you join to a dimension table and a piece of metadata changes, does that change now need to be updated and reflected back in all of this historical aggregate data that's outside of the automatic refresh policy? Same with a window function - if data within a window hasn't changed but data that *might* be hit because of the window function reference does ch
Read the rest
ange, continuous aggregates would have to know about that for each query and track those changes too. I'm not saying it's impossible or that it won't be solved someday, but the functionality with continuous aggregates that keeps the aggregate data updated automatically (without losing any history) *and* being able to perform fast joins on the finalized data is a very useful step that's not available anywhere else within the Postgres ecosystem. RE: CAGG on top of a CAGG - you're certainly not the only person to request this[1] () and we understand that. Part of this is because of what I discussed above (tracking changes across multiple tables), although having finalized data might make this more possible in the future. That said (!!!), the cool thing is that we already *have* begun to solve this problem with hyperfunction aggregates and 2-step aggregation, something I showed in the blog post. So, if your dataset can benefit from one of the hyperfunction aggregates that we currently provide, there are lots of cool things you can do with it, including rollups into bigger buckets without creating a second continuous aggregate! If you haven't checked them out, please do! [2][3] [1]: https://github.com/timescale/timescaledb/issues/1400 [2]: https://www.timescale.com/blog/introducing-hyperfunctions-ne... [3]: https://www.timescale.com/blog/how-postgresql-aggregation-wo...
In How we made data aggregation on PostgreSQL better and faster
Hi! So the team is over 100 at this point, but engineering effort is spread across multiple products at this point. The core timescaledb repo [0] currently has 10-15 primary engineers, with a few others working on DB hyperfunctions and our function pipelining [1] in a separate extension [2]. I think generally the set of outside folks who contribute to low-level database internals in C is just smaller than other type of projects. We also have our promscale product [3], which is our observability backend powered by SQL & TimescaleDB. And then there is Timescale Cloud [4], which is obviously a large engineering effort, most of which does not happen in public repos. Interested? We're growing the teams aggressively! Fully remote & global. https://www.timescale.com/careers -- [0] https://github.com/timescale/timescaledb [1] https://www.timesc
Read the rest
In Timescale raises $110M Series C

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.