Introducing Lix: A universal version control system | Lix BloglixDocsPluginsBlogGitHub112BlogIntroducing Lix: A universal version control systemSamuel Stroschein4 min readCopy URLJanuary 20, 2026Introducing Lix: A universal version control system
AI agents need version control beyond text
Changes AI agents make need to be reviewable by humans.
For code, Git solves this:

Reviewable diffs: What exactly did the agent change?
Human-in-the-loop: Review, then merge or reject.
Rollback changes: Undo mistakes instantly.

But agents modify binary files too. And Git can't diff them.

Introducing Lix
Lix is a universal version control system that can diff any file format (.xlsx, .pdf, .docx, etc).
Unlike Git's line-based diffs, Lix understands file structure. Lix sees price: 10 → 12 or cell B4: pending → shipped, not "line 4 changed" or "binary files differ".

Reviewable diffs: See exactly what an agent changed in any file format.
Human-in-the-loop: Agents propose, humans approve.
Safe rollback: Undo mistakes instantly.

Excel file example
An AI agent updates an order status in orders.xlsx.
Before:
| order_id | product | status |
| -------- | -------- | -------- |
| 1001 | Widget A | shipped |
| 1002 | Widget B | pending |

After:
| order_id | product | status |
| -------- | -------- | -------- |
| 1001 | Widget A | shipped |
| 1002 | Widget B | shipped |

Git sees:
-Binary files differ

Lix sees:
order_id 1002 status:

- pending
+ shipped

JSON file example
Even for structured text file formats like .json lix is tracking semantics rather than line by line diffs.
Before:
{"theme":"light","notifications":true,"language":"en"}

After:
{"theme":"dark","notifications":true,"language":"en"}

Git sees:
-{"theme":"light","notifications":true,"language":"en"}
+{"theme":"dark","notifications":true,"language":"en"}

Lix sees:
property theme:
- light
+ dark

How does Lix work?
Lix adds a version control system on top of SQL databases that let's you query virtual tables like file, file_history, etc. via plain SQL. These table's are version controlled.
Why this matters:

Lix doesn't reinvent databases — durability, ACID, and corruption recovery are handled by battle-tested SQL databases.
Full SQL support — query your version control system with the same SQL.
Can runs in your existing database — no separate storage layer to manage.

┌─────────────────────────────────────────────────┐
│ Lix │
│ (version control system) │
│ │
│ ┌────────────┐ ┌──────────┐ ┌─────────┐ ┌─────┐ │
│ │ Filesystem │ │ Branches │ │ History │ │ ... │ │
│ └────────────┘ └──────────┘ └─────────┘ └─────┘ │
└────────────────────────┬────────────────────────┘
│
▼
┌─────────────────────────────────────────────────┐
│ SQL database │
└─────────────────────────────────────────────────┘

Read more about Lix architecture →
Why did we build lix?
Lix was developed alongside inlang, open-source localization infrastructure.
We had to develop a new version control system that addressed git's limitations inlang ran into, see (see "Git is unsuited for applications"). The result is Lix, now at over 90k weekly downloads on NPM.

Getting started

JavaScript ·
Python ·
Rust ·
Go

npm install @lix-js/sdk

import { openLix } from "@lix-js/sdk";

const lix = await openLix({
environment: new InMemorySQLite()
});

await lix.db.insertInto("file").values({ path: "/hello.txt", data: ... }).execute();

const diff = selectWorkingDiff({ lix })

What's next
The next version of Lix will be a refactor to be purely "preprocessor" based. This enables:

Fast writes (RFC 001)
Any SQL database (SQLite, Postgres, Turso, MySQL)
SDKs for Python, Rust, Go (RFC 002)

┌────────────────┐
SELECT * FROM ... │ Lix Engine │ SELECT * FROM ...
───────────────────▶ │ (Rust) │ ───────────────────▶ Database
└────────────────┘

Join the community

⭐ Star the lix repo on GitHub
💬 Chat on Discord
Get notified about new blog postsEnter your email📘Docs📝Blog📄RFCs💬Discord⭐Star on GitHub112

Lix: A Universal Version Control System – Addressing Limitations of Git

The document introduces Lix, a new, universal version control system designed to overcome the limitations of existing systems like Git, particularly when dealing with non-text file formats. Lix fundamentally shifts the approach to version control by focusing on semantic understanding rather than line-based comparisons, offering a more granular and intuitive review process for AI-driven changes.

The core issue highlighted is Git’s inability to effectively handle binary files. Git’s “binary files differ” message provides minimal information, making it difficult for human reviewers to understand the actual changes made by an AI agent. Lix addresses this by recognizing file structure and the meaningful differences within these files – for example, a change in cell B4 from “pending” to “shipped” in an Excel file, or a change in JSON keys and values, rather than simply identifying that the file has been modified at the byte level.

Key Features and Functionality:

* **Semantic Versioning:** Lix utilizes a system that analyzes file structures and semantic relationships, understanding the meaning behind changes within files, regardless of the file type.
* **Reviewable Diffs:** Lix provides precise, understandable diffs outlining exactly what an agent has modified, facilitating human review and approval.
* **Human-in-the-Loop Workflow:** The system supports a collaborative workflow where AI agents propose changes, and human reviewers provide the final approval or rejection.
* **Safe Rollback:** Lix enables immediate and safe reversion to previous versions if errors are detected.
* **SQL-based Architecture:** Lix is built upon a SQL database foundation, leveraging the robustness and capabilities of SQL databases for data storage and management. This allows for consistent querying and version control operations.
* **Integration with Existing Infrastructure:** Lix integrates seamlessly into existing databases, eliminating the need for separate storage layers, simplifying deployment and maintenance, and relying on tested SQL databases.

How Lix Works:

At its core, Lix implements a version control system that operates on top of SQL databases. This abstraction provides two key virtual tables: `file` and `file_history`, which can be queried using standard SQL. This approach ensures data durability, ACID properties, and corruption recovery, all managed by established SQL database systems. The SDK provides Rust, Javascript, Python, Go for querying the lix database. The next version of lix will be a refactor to be purely “preprocessor” based.

Development Context:

Lix was developed concurrently with inlang, an open-source localization infrastructure. The need for a new version control system arose from the challenges encountered by inlang, specifically, that Git was ill-suited for their application. The resulting product, Lix, boasts over 90,000 weekly downloads on NPM. The next version of Lix will be a refactor to be purely “preprocessor” based.

Looking Ahead:

Future development includes a refactoring to a “preprocessor” model, which promises to offer:

* Fast Writes (RFC 001): Enhanced performance for write operations.
* Database Agnostic Support (RFC 002): Compatibility with various SQL databases, including SQLite, PostgreSQL, Turso, and MySQL.
* Updated SDKs: Continued support for Rust, Javascript, Python, and Go.

In conclusion, Lix represents a significant advancement in version control systems, particularly for AI-driven applications that require granular, human-understandable feedback on file changes. Its SQL-based architecture, combined with its semantic understanding, provides a robust and flexible solution for managing evolving data, leveraging proven database technologies.