
Fast,Scalable,Distributed revision control system
Showing 5 of 26 projects. Click any project card for scope, mentors, and proposal studio.
Mentors: Student: Pablo Sabater
Git's partial clone allows cloning repositories without downloading all objects (blobs, trees, ...). These objects are fetched on demand from the remote when needed. However, when a user needs metadata about these remote objects (size, type, hash, ...), Git has no efficient way of doing this without downloading all the object content. The server side support for `object-info` protocol was implemented by Calvin Wan in 2021. Eric Ju built the client-side `remote-object-info` for `cat-file --batch-command`. This project finishes Eric Ju's work on `remote-object-info` for `git cat-file --batch-command`, resolves the pending feedback from Junio Hamano and Jeff King, and extends support for `%(objecttype)`. The main technical fix is to replace the insufficient `strstr()` format validation with an `allow_list` to prevent crashes on unsupported placeholders, and extending the v2 protocol server and client to handle `%(objecttype)`. After the project, Git will have a working `remote-object-info` for `cat-file --batch-command` supporting `%(objectsize)`, and a v2 protocol extension adding `%(objecttype)` support on both server and client, with tests and documentation.
Mentors: Student: K Jayatheerth
The new git repo command doesn't handle file paths yet, and it forces users to dump all repository data at once instead of just requesting what they need. This makes scripting difficult and forces developers to keep using the older git rev-parse command. This project improves the git repo info command in two main ways: First, by adding path.* keys (like path.git-dir) that can return both absolute and relative paths. Second, by building a fast, lightweight search system (O(log N)) so users can easily query specific categories of information. As a stretch goal, the project will evolve git repo structure into a diagnostic tool by introducing metric distributions, such as object size and entry histograms.
Mentors: Student: Tian Yuchen
Git’s core C codebase still relies heavily on global state, such as the_repository and various environment-derived variables defined in environment.c. While this design was sufficient for a standalone CLI tool, it becomes problematic in more demanding scenarios. In particular, the reliance on implicit global state makes it difficult to safely embed Git as a library. Functions may read configuration or environment variables through global state, and in some cases call die(), which terminates the entire process. This behavior is incompatible with long-running or multi-threaded applications that need finer-grained control over error handling and repository isolation. Building upon the ongoing work from previous GSoC and Outreachy efforts, this project focuses on reducing such global dependencies by making state explicit. Where appropriate, repository-specific data will be passed through struct repository and related structures such as repo_settings or repo_config_values. Subsystem-specific variables will be localized to their respective domains instead of remaining globally accessible. By replacing implicit global assumptions with explicit data structure, this work aims to make Git’s internal APIs easier to reason about, safer to use in multi-repository contexts, and more suitable for long-term libification.
Mentors: Student: Siddharth Shrimali
Problem: Git's "partial clone" is a lifesaver for huge repos because it lets you download only the files you actually need. But once you download a file (a "blob"), it stays on your disk forever. Currently, Git has no way to "un-fetch" these files. Over time, your "partial" clone starts looking like a massive full clone, and the only fix is to delete everything and start over. Solution: I want to build a "reverse gear" for partial clones. My project will add a safe way for Git to drop large, local files you no longer need, while keeping a "promise" that it can get them back from the server later. I’ll be focusing on three main things: Safety: Ensuring Git double-checks that the server still has the file before we delete it locally. "Promise" Contract: Updating Git’s internal records so it knows a deleted file isn't missing, just stored remotely. User Control: Adding this to git maintenance so users can easily reclaim space without being C experts. By the end of the summer, Git will have a new capability to prune local blobs safely. This includes the core C logic for identifying and removing objects, integration with the git maintenance command, and a full suite of tests to ensure no data is ever lost.
Mentors: Student: Lucas Oshiro
This project introduces a new Git sub-command (currently intended to be called git repo-info) that will centralize data currently retrieved by git rev-parse in a JSON format.