A New Tool Helps Developers Merge Code Without Conflicts

A company called Ataraxy Labs has released Weave, a new tool that makes it easier for software developers to combine their work when they have made separate changes to the same file.

The Problem It Solves

When multiple developers work on the same software project, they often edit the same file independently. Later, they need to merge those changes back together. Today's standard approach — used by Git, the software that manages nearly all code collaboration — looks at files line by line, much like how a word processor's "track changes" feature works. If two developers edited lines near each other, Git assumes there is a conflict and asks a human to fix it, even if the changes are completely separate and would work fine together.

This happens a lot in the real world. Imagine two developers adding new features to the same file: one adds a new function near line 50, and another adds a different new function near line 70. Git sees changes in the same general region and flags it as a problem, even though the functions have nothing to do with each other.

How Weave Works

Weave approaches the problem differently. Instead of looking at lines of text, it understands the actual structure of the code. It uses a parsing library called tree-sitter to read a file and recognize where functions, classes, and methods begin and end — the semantic building blocks of code. With this structural understanding, Weave can tell that two separate functions in the same file are genuinely separate, and it can merge them without human intervention.

The tool is written in Rust and integrates into Git's normal merge process, so developers do not need to change how they work. They configure it once, and it runs automatically.

Ataraxy Labs also maintains a companion project called Sem, which applies the same structural approach to tracking code changes over time, not just at merge time.

Why It Matters Now

The current generation of AI coding tools — like GitHub Copilot and Cursor — has changed how code gets written. These assistants tend to produce self-contained pieces: one new function, or one refactored section. That pattern means more developers working on more branches, and more changes landing in the same files. The old line-by-line approach to merging breaks down faster in this environment.

The broader context here is what Ataraxy Labs seems to be preparing for: a development environment where AI agents — not just tools assisting humans, but autonomous systems — commit and merge code on their own, alongside human developers. If that future arrives, a merge tool that cannot tell the difference between truly conflicting changes and merely nearby changes becomes a real barrier, not just an occasional headache.

The Practical Reality

Before teams start using Weave, they should know about one practical limitation. The tool relies on tree-sitter, which needs grammar definitions for each programming language it supports. Tree-sitter covers a lot of languages, but the quality is uneven — some grammars are battle-tested, others are still being refined. If you use a less common language, or work in a codebase that jumps between many languages, you may find that Weave cannot yet understand your code well enough to work reliably. That is not a flaw in Weave itself, but rather a constraint built into how it was designed.

For teams already using AI to help write code, and teams that deal with a lot of parallel development, this tool is worth experimenting with. The merge conflict problems it is designed to solve are real, and it offers a straightforward way to reduce manual cleanup.

The project is open source and available on GitHub.