Open-source project
timelinize/timelinize avatar
timelinize/timelinize

timelinize says an upgrade means recreating your timeline

Store your data from all your accounts and devices in a single cohesive timeline on your own computer

3,706 stars134 forksGoAGPL-3.0

At a glance

What is it?
A self-hosted aggregator that turns data you export from accounts into one local timeline, where the page warns that every upgrade means deleting and recreating your timelines, the HTTP API and the CLI are the same generated surface with no authentication described, and the Docker build compiles libvips from a git clone.
Who is it for?
Timelinize is the right tool if the point is owning a copy of your own history rather than renting access to it, since the original files stay where they were and the index over them is a SQLite database you can inspect. Two things to know before you rely on it.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository last received commits 177 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • timelinize/timelinize3,706 ★ · +45
Star history
Repository2026-09-112026-11-15
timelinize/timelinize3.7k3.7k

45 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

An upgrade means deleting and recreating your timelines

The page carries a caution block, and it is the most important thing on it. Timelinize is in active development and is still unstable. The schema is still changing, necessitating starting over from a clean slate when updating. Always keep your original source data. Expect to delete and recreate your timelines as you upgrade to new versions or builds. That is four instructions, and for a tool whose stated purpose is keeping data alive and owned forever, the data itself is the part that survives and the timeline is the part that gets thrown away. The tag history is consistent with that: v0.0.26, v0.0.27 and v0.0.28 were published within eight days in October 2025, all still numbered zero, and the last commit to the default branch is dated 2026-05-22, about seven months after the newest of them.

The index is SQLite and your files stay where they were

The import step makes two promises worth quoting closely. You do not need to extract or decompress `.tar` or `.zip` archives, because Timelinize will attempt to recognize your data in its original format and folder structure. And all the data you import is indexed in a SQLite database and stored on disk organized by date, with no obfuscation and no proprietary formats, so you can simply browse your files if you wish. That combination is the right shape for the stated goal: the tool is a reader and an index over data you already exported, not a container that swallows it. Re-importing is also cheap, since Timelinize skips any existing data that is the same and only imports new content, which is what makes a repeated every-few-weeks routine practical.

The API and the CLI are one generated surface

The two interfaces are not maintained separately. Timelinize has a symmetric HTTP API and CLI, and when an HTTP API endpoint is created in the code it automatically adds to the command line as well.

code
timelinize help

Run it, or `go run main.go help` from source, to see the list of commands, which are also the HTTP endpoints. JSON or form inputs are converted to command line args and flags that represent the JSON schema or the form fields, so the flag surface is a rendering of the data model rather than something designed. One thing the page never comes back to: there is nothing about authentication, tokens or access control on that HTTP surface. For an application whose database holds years of private messages, contact lists and location history, and which is designed to be reachable, that omission is the first gap a reader has to fill in themselves.

Entities are first class, and conversations are derived

The screenshots section explains the model better than any paragraph would. Timelinize treats entities, meaning people, pets, animals and organizations, as first class data points you can filter and organize, and it will automatically recognize the same entity across data sources when there is enough information, with a click to merge entities manually when there is not. Conversations are not stored as conversations: they are aggregated across data sources that have messaging capabilities and become emergent from the database by querying relationships between items and entities, which is why a view can show messages exchanged on both Facebook and SMS together with reactions. The map view has the consequence worth flagging. Because the model is entity aware, it can show data on a map even when it has no geolocation of its own, and the page says so: a text message is placed at a church because of who received it.

A data faking library is a hard runtime dependency

The `require` block in `go.mod` lists `github.com/brianvoe/gofakeit/v7` among the direct dependencies, not in a test group and not behind a build tag. That library generates fake values, and the page's demo mode is built on it: screenshots and videos portray real timelines in demo mode which obfuscates sensitive information, with images blurred, names and other identifiers replaced with random data and some locations faked. So the substitution layer is a first class dependency of every install, whether or not you ever open demo mode. Three other entries explain parts of the design: `sqlite-vec-go-bindings` at v0.1.6 for vector search inside SQLite, `go.n16f.net/thumbhash` for cheap image placeholders, and `github.com/cshum/vipsgen`, a binding generator for libvips, which is what makes the Docker build as heavy as it is.

A required dependency is immediately redirected to a fork

`go.mod` requires `github.com/cozy/goexif2 v1.3.1` and, in a `replace` line above the require blocks, substitutes `github.com/mholt/goexif2` for it at a pseudo-version.

code
replace github.com/cozy/goexif2 => github.com/mholt/goexif2 v0.0.0-20250912034845-8dfb3070976a

So the EXIF reader every build uses is not the one the manifest names. That is a normal thing to do when an upstream is unmaintained, and it is worth reading rather than skipping because the required version number still looks supported. One more pin deserves the same attention: `github.com/mholt/archives`, the archive reader that makes the no-extraction import work, is pinned to `v0.1.0-20251107150748`, a pseudo-version from November 2025 rather than a tagged release.

The Docker build clones libvips and compiles it

The image build is not a package install. It starts `FROM golang:1.25-trixie AS builder`, appends the trixie-backports source line, installs roughly twenty build packages including meson, ninja, pkg-config, libraw-dev and ffmpeg, and then does this.

code
git clone --depth 1 https://github.com/libvips/libvips.git /tmp/libvips

From there it runs a meson setup with `--wrap-mode=forcefallback --backend=ninja`, builds with ninja, installs, runs ldconfig, sets `ENV CGO_ENABLED=1` and finishes with `go build -o /app/timelinize`. The runtime stage is `debian:trixie-slim` with the shared libraries copied across. A shallow clone of the image library's master branch, compiled during the build, means two builds a week apart are not the same image, and a broken upstream commit fails your build rather than yours. The module cache and the build cache are mounted so the Go side is cached, which makes the libvips clone the only uncached piece.

The Makefile disclaims itself and builds one platform

The Makefile opens by saying it is a community-maintained Makefile, that it is not officially supported by the project owner, and to feel free to use it and help improve it. It then checks for `zig` and `vips` on the path and installs both with `brew install`, with a matching `dep-del` target running three `brew uninstall` commands, so the whole thing is Homebrew shaped. What `bin` builds is one binary.

code
go build -o $(BIN_ROOT)/$(BIN_NAME)_darwin_arm64

The linux amd64 line above it is commented out, and `bin-cross` has linux arm64 and windows amd64 active while its windows arm64 line stops partway through. The readme carries a second piece of archaeology: a commented out block titled Wails UI info, no longer used, which records the last commit that used Wails as a hash, the last working Wails commit released as a dev preview as a different hash, and the reason for the change, that in July-August 2023 the project moved to a client/server model because Webkit2GTK performed badly enough to crash frequently, even on Mac.

Editorial conclusion

Timelinize is the right tool if the point is owning a copy of your own history rather than renting access to it, since the original files stay where they were and the index over them is a SQLite database you can inspect. Two things to know before you rely on it. The page's own caution says the schema is still changing and that an upgrade means starting over from a clean slate, so treat the source exports as the real archive and the timeline as a rebuildable view. And the API surface says nothing about access control, while the app will place a message on a map based on who received it, so decide where that server sits before you import a decade of messages.

Frequently asked questions

What does Timelinize do?

It organizes photos and videos, chats and messages, location history, social media content and contacts into a single timeline stored on your own computer. It imports from accounts, devices and apps, indexes everything in a SQLite database, and leaves the original files in place rather than converting or obfuscating them.

Is Timelinize stable enough to rely on?

The page says it is in active development and still unstable, that the schema is still changing, and that this means starting over from a clean slate when updating. It advises keeping your original source data and expecting to delete and recreate timelines as you upgrade to new versions or builds.

Does Timelinize send my data anywhere?

The page describes no upload. It says all imported data is indexed in a SQLite database and stored on disk organized by date, with no obfuscation and no proprietary formats, so you can browse the files directly. The licence is AGPL-3.0 and the project site is timelinize.com.

Does the Timelinize API need authentication?

The page does not say. It describes a symmetric HTTP API and CLI where every endpoint added in the code also appears on the command line, with JSON or form fields converted to flags, and it says nothing about authentication, tokens or access control on that surface.

What does Timelinize need to build from source?

The Docker path clones libvips from GitHub at depth one, compiles it with meson and ninja, and needs Go with CGO enabled. The Makefile checks for zig and vips on the path and installs both with brew, and it carries a notice saying it is community-maintained and not officially supported by the project owner.

Where does Timelinize get its data from?

You export it yourself. The page points at a data preparation document, gives requesting an archive from Google Takeout as the example, and notes that Apple iCloud, Facebook, Twitter/X, Strava and Instagram all offer similar exports for GDPR compliance. It also lists GPS-enabled radios, contact lists and cameras among the sources.

Official sources

  1. License: AGPL-3.0
  2. Project website
  3. README
  4. Releases
  5. timelinize/timelinize on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/timelinize-timelinize.svg)](https://hysenlabs.com/projects/timelinize-timelinize)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/timelinize-timelinize.svg)](https://hysenlabs.com/projects/timelinize-timelinize)

Was this useful?