Grit: Rewriting Git in Rust with agents

A developer has announced Grit, a new implementation of Git written entirely in Rust, which uses an agent-based approach to improve modularity, safety, and performance. This project aims to pass over 99% of the Git test suite and offers potential for new applications such as embedded Git tools and WebAssembly builds.

Grit is a from-scratch, library-based, memory-safe reimplementation of Git, developed over several months with the goal of creating a fully modular and reentrant core library in Rust. It currently passes more than 99% of the extensive Git test suite, although some parts are intentionally skipped, such as email handling and certain importers. The project was inspired by Anthropic’s experiments with agent-based code generation, applying a similar concept to rewrite Git.

While still in early stages, Grit aims to address limitations of existing Git implementations like libgit2 and Gitoxide, especially in network operations and embedding capabilities. The developer emphasizes that the project is not yet production-ready, with performance issues and incomplete features, but sees it as a promising foundation for future development and integration into tools such as GitButler, Jujutsu, and WebAssembly environments.

Potential Impact on Git Ecosystem and Development

Grit represents a significant step toward a fully modular, safe, and embeddable Git implementation in Rust. Its agent-based development approach could lead to more reliable, customizable, and efficient Git tools, especially for embedded systems, web-based applications, and networked workflows. If successful, it may influence future Git development and inspire similar projects leveraging agent-based techniques for complex software rewriting.

Background and Motivation for Rewriting Git in Rust

Git, created incrementally over the past 20 years, is a complex system with many commands and features. Its traditional implementation in C has limitations in safety, modularity, and integration with modern environments. Existing Rust implementations like libgit2 and Gitoxide have addressed some issues but still face challenges in performance, network functionality, and embedding. Inspired by Anthropic’s experiments with agent-based code generation, the developer of Grit sought to explore whether a swarm of agents could help rewrite Git from scratch, aiming for a more flexible and safer core library.

Previous efforts to reimplement Git have been incremental or partial, but Grit aims to be a comprehensive, library-based core that can pass most tests and serve as a foundation for future tools and integrations. The project is still early-stage, with many features and performance optimizations to develop.

“Grit is a from-scratch, library-based, memory-safe, idiomatic Rust reimplementation of Git that passes over 99% of the Git test suite.”

— Developer behind Grit

“We didn’t do this just to see if it could be done; we believe Grit can evolve into a useful tool for embedding Git functionality in various environments.”

— Project developer

Remaining Challenges and Development Uncertainties

Grit is not yet fully tested for all use cases, with some test suites skipped intentionally. Performance remains an issue, especially in some operations that can become exponentially slow. The API design is still rough, and Windows support is absent. It is unclear how quickly these issues will be resolved or whether Grit will achieve full production readiness in the near term.

Next Steps for Grit Development and Adoption

Further development will focus on optimizing performance, expanding test coverage, and refining the API. The developer plans to add Windows support and integrate Grit into existing tools like GitButler and Jujutsu. Community feedback and bug reports will be essential to guide improvements. Additionally, exploring WebAssembly builds could open new use cases, such as running Git commands in serverless environments or embedded systems.

Key Questions

What is Grit and how is it different from existing Git implementations?

Grit is a new, from-scratch implementation of Git written in Rust, designed to be modular, safe, and embeddable. Unlike traditional Git in C or existing Rust ports, it uses an agent-based approach to improve flexibility and safety.

Is Grit ready for production use?

No, Grit is still in early development. It currently passes most tests but has performance issues and incomplete features. Use it at your own risk.

What are the potential applications of Grit?

Grit could enable embedding Git in Rust applications, improve network operations for tools like GitButler, support WebAssembly environments, and facilitate custom Git server or client implementations.

How does Grit ensure safety and modularity?

Most of Grit’s code is written in memory-safe Rust, with only minimal FFI for time-related functions. Its design emphasizes a reentrant, linkable core library that can be integrated into various tools.

What are the main challenges Grit faces moving forward?

Performance optimization, API refinement, complete test coverage, and platform support remain key challenges before Grit can be considered production-ready.

Source: Hacker News