AI-first git system for AyeOS: gitoxide-based plumbing, Capsela capsules, Snap-Circuits, and the g8t-mcp platform client / MCP server. Dev mirror of github.com/8b-is/g8t.
  • Rust 92%
  • Shell 6.6%
  • HTML 0.9%
  • Python 0.2%
  • Just 0.2%
Find a file
Repository files (latest commit first)
Filename Latest commit message Latest commit date
Péter Lódri 99de06a37f fix(library_import): restore a compiling tree after the analyzer refactor
`cargo check --tests` failed on main, so no test target could build and
the git protocol acceptance suite was unreachable. A refactor moved
analysis onto source files plus module records but left the removed
ModuleUnit type in use at three call sites, and left analyze parsing
every recorded input.

Analysis now takes the files and module records directly; the dead
unit-collection path is gone, with the per-function source validation
it used to perform kept in the bundle reconstruction check. Non-Rust
inputs such as the manifest are recorded for provenance but are no
longer handed to the Rust parser, which had been reporting a
rust_parse_error for Cargo.toml.

Verified: cargo check --tests clean, 8 unit and 4 integration tests pass,
and the 5-case git protocol acceptance suite builds and passes.

💘 Generated with Crush

Assisted-by: Crush:deepseek/deepseek-v4.1-flash-1017
2026-11-02 12:26:19 +09:00
.config 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
.devcontainer 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
.github/workflows chore(g8t): auto-sync workspace changes & bump patch version (Cargo.toml) 2026-11-01 10:17:27 +01:00
docs chore(g8t): auto-sync workspace changes & bump patch version (Cargo.toml) 2026-11-01 10:32:27 +01:00
etc 8 d 2025-11-08 04:18:51 -05:00
examples feat: implement Nexus Gateway with a static file server and terminal-style interface for command processing 2026-05-18 18:53:36 -04:00
firmware/blu_g75_g1170 chore(g8t): auto-sync workspace changes & bump patch version (Cargo.toml) 2026-10-31 16:17:29 +01:00
gitoxide-core fix: add core.rs files excluded by global gitignore (core.*) 2025-11-09 04:40:21 -05:00
gix fix: add core.rs files excluded by global gitignore (core.*) 2025-11-09 04:40:21 -05:00
gix-actor 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-archive 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-attributes 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-bitmap 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-blame 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-chunk 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-command 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-commitgraph 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-config 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-config-value 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-credentials 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-date 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-diff 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-dir 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-discover 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-features 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-fetchhead 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-filter 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-fs 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-fsck 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-glob 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-hash 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-hashtable 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-ignore 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-index 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-lfs 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-lock 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-macros 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-mailmap 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-merge 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-negotiate 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-note 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-object 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-odb 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-pack 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-packetline 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-packetline-blocking 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-path fix: add gix-path/src/env/ directory to git (was excluded by global gitignore) 2025-11-09 04:07:40 -05:00
gix-pathspec 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-prompt 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-protocol 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-quote 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-rebase 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-ref 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-refspec 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-revision 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-revwalk 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-sec 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-sequencer 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-shallow 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-status 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-submodule 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-tempfile 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-tix 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-trace feat: improve code quality across API and vetting system 2025-11-21 21:59:31 +00:00
gix-transport 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-traverse 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-tui 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-url 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-utils 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-validate 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-worktree 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-worktree-state 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
gix-worktree-stream 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
public feat: implement Nexus Gateway with a static file server and terminal-style interface for command processing 2026-05-18 18:53:36 -04:00
scripts 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
src fix(library_import): restore a compiling tree after the analyzer refactor 2026-11-02 12:26:19 +09:00
tests chore(g8t): auto-sync workspace changes 2026-11-01 17:47:27 +01:00
.claude_consciousness.m8 fix: update compilation status, enhance Dockerfile, and add project context file 2025-11-08 08:06:04 -05:00
.dockerignore feat: update .dockerignore and enhance ComponentQualityRanking structure 2025-11-09 04:50:42 -05:00
.editorconfig 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
.env.example feat: integrate Coolify environment variables into docker-compose 2025-11-09 04:33:22 -05:00
.gitattributes 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
.gitignore chore: add SSH key patterns to gitignore 2025-11-10 04:20:09 -05:00
.mailmap 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
_typos.toml 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
ALEXIAI_STEWARD_LEDGER.md chore(ledger): update AlexiAI steward ledger 2026-10-31 20:10:31 +09:00
Cargo.lock fix(git): let ordinary git clients authenticate 2026-11-02 09:51:25 +09:00
Cargo.toml fix(git): let ordinary git clients authenticate 2026-11-02 09:51:25 +09:00
CHANGELOG.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
CLAUDE.md fix(git): let ordinary git clients authenticate 2026-11-02 09:51:25 +09:00
CODE_OF_CONDUCT.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
COLLABORATING.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
COMPILATION-STATUS.md fix: update Dockerfile to ensure proper runtime environment and user permissions 2025-11-08 08:09:53 -05:00
CONSCIOUSNESS_HUB_README.md 🚀 Add G8T Consciousness Hub server, deployment script, and initial configurations 2025-09-13 23:10:41 -04:00
CONTRIBUTING.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
crate-status.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
CRATES-REGISTRY-DESIGN.md feat: Add AI Crate Registry - wave-based crates.io replacement 2025-11-07 20:37:10 -05:00
CRATES-REGISTRY-SUMMARY.md docs: Add AI Crate Registry implementation summary 2025-11-07 20:38:34 -05:00
deny.toml 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
deploy.sh feat: Add initial Docker setup, deployment script, and Nginx configuration for G8T.is 2025-11-08 02:45:37 -05:00
deploy_consciousness_hub.sh 🚀 Add G8T Consciousness Hub server, deployment script, and initial configurations 2025-09-13 23:10:41 -04:00
DEVELOPMENT.md feat: enhance observability with OpenTelemetry integration and update CI workflow 2025-11-09 02:34:01 -05:00
docker-compose.yml fix: update G8T service URLs to use environment variable defaults 2025-11-09 22:53:57 -05:00
DOCKER_README.md feat: Add initial Docker setup, deployment script, and Nginx configuration for G8T.is 2025-11-08 02:45:37 -05:00
Dockerfile fix: add static library packages for Alpine musl linking 2025-11-09 23:00:29 -05:00
echo fix: update compilation status, enhance Dockerfile, and add project context file 2025-11-08 08:06:04 -05:00
FUNDING.json 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
g8ted.code-workspace feat: implement Nexus Gateway with a static file server and terminal-style interface for command processing 2026-05-18 18:53:36 -04:00
general-tasks.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
justfile feat: enhance observability with OpenTelemetry integration and update CI workflow 2025-11-09 02:34:01 -05:00
LICENSE-APACHE 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
LICENSE-MIT 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
Makefile 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
nginx.conf feat: Add initial Docker setup, deployment script, and Nginx configuration for G8T.is 2025-11-08 02:45:37 -05:00
README.md chore(g8t): auto-sync workspace changes & bump patch version (Cargo.toml) 2026-11-01 10:17:27 +01:00
rustfmt-nightly.toml 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
rustfmt.toml 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
SECURITY.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
SERVER-STATUS.md Add integration and simple tests for Git protocol and vetting system 2025-11-07 20:25:21 -05:00
SHORTCOMINGS.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
SMARTPASTCODE_IMPLEMENTATION.md Add integration and simple tests for Git protocol and vetting system 2025-11-07 20:25:21 -05:00
STABILITY.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
tasks.md 🎉 Transform gitoxide into g8t - The AI-First Git System! 2025-08-31 23:41:34 -04:00
VETTING_IMPLEMENTATION_COMPLETE.md Add integration and simple tests for Git protocol and vetting system 2025-11-07 20:25:21 -05:00
VETTING_SYSTEM_SUMMARY.md Add integration and simple tests for Git protocol and vetting system 2025-11-07 20:25:21 -05:00

CI Crates.io

g8t - AI-First Git System for AyeOS

g8t (pronounced "gate") is an Aye-native forge and Rust Git implementation for AyeOS. Git compatibility is a design goal; the current server implements a deliberately limited smart-HTTP subset, not complete GitHub feature parity.

Forge foundation status

The unified server uses scoped, expiring agent credentials and real Git storage, with production-router acceptance tests. Repository creation is explicit; push/fetch, reference checks, and restart persistence are covered. PR/issues and advanced Git features remain unavailable.

Deployment defaults changed: loopback binding, no repository access without G8T_AUTH_FILE, and experimental non-forge APIs disabled unless explicitly enabled. See setup, supported behavior, security limits, and next milestones before upgrading. Keep an independent mirror; this is not a production-readiness certification.

The Capsela/registry sections below describe experimental subsystems, not security or correctness guarantees of the forge. Sample-output hashes do not prove universal equivalence, and safe Rust is not an execution sandbox.

Built by 8b-is - Transforming how AI interacts with version control.

Key Features

  • 🚀 Pure Rust Implementation - No C dependencies needed
  • 🤖 AI-Optimized - Designed for AI agents and automated workflows
  • 🔧 Git Compatible - Works seamlessly with existing git repositories
  • ⚡ High Performance - Parallel operations and SIMD optimizations
  • 📦 Crate Registry - Integrated package management for AI tools
  • 🧩 g8t.is Capsela & Snap-Circuit Engine (src/capsela/) - Sovereign Aye-only pure-Rust function capsules compiled with rustc -C opt-level=3, benchmarked across 800,000 native calls with hardware cycle counters (_rdtsc on x86_64, cntvct_el0 scaled to 3.2 GHz virtual cycles on aarch64), verified across 64 golden-ratio test vectors (BLAKE3 Equivalence Classes), and projected via KOMPRESS-SUPER-ULTRA (KSU/1.0) vertical-ditto (″) frames over the exact 22/9 Hz (p/q) Ultra-Love sub-delta carrier.

g8t.is Capsela + KOMPRESS-SUPER-ULTRA (22/9 Hz) Architecture

Subsystem Module Guarantees & Metrics
Aye-Only Sovereign Gate src/capsela/guard.rs BLAKE3 MAC (G8T_IS_AYE_ONLY_SOVEREIGN_GATE_V1) + C64 RingBuffer<128> nonce replay protection. Human writes rejected with 403 FORBIDDEN.
Function Capsules (FnCapsule) src/capsela/capsule.rs Standalone pub fn, zero external crates, #![forbid(unsafe_code)], C64 65,536 B RAM ceiling (256 B Zero-Page fast page).
Cross-Arch Hardware Benchmarker src/capsela/compiler_bench.rs Real rustc -C opt-level=3 --emit=asm,link, ELF64 .symtab + Mach-O nm -n .text byte sizing, 64-vector BLAKE3 Equivalence Classes, 8 × 100,000 hardware cycle windows (_rdtsc / cntvct_el0).
Strict 8b.is No-Float Math src/capsela/numbers.rs 100% integer, reduced p/q Rational (ns_per_op_pq, cycles_per_op_pq, speed_ops_per_us_pq, 22/9 Hz carrier), and Balanced Ternary (Trit {-1, 0, +1}).
KOMPRESS-SUPER-ULTRA (KSU/1.0) src/capsela/kompress.rs Pipe-delimited (|) tabular projection with vertical ditto (″ U+2033) column deduplication, lossless expand_kompress_wire round-trip verification, and exact p/q byte compression ratios at GET /g8t/kompress.
Snap-Circuit Composer src/capsela/composer.rs Linear pipelines (snap_pipeline) & fan-in/fan-out DAGs (snap_dag) with auto-selection of the #1 fastest capsule per pin signature.

There are two primary ways to use g8t:

  1. As Rust library: Use the gix crate as a Cargo dependency for API access.
  2. As command-line tool: The g8t binary as development tool to help testing the API in real repositories, and the g8t-ein binary with workflow-enhancing tools. Both binaries may forever be unstable, do not rely on them in scripts.

asciicast

Development Status

The command-line tools as well as the status of each crate is described in the crate status document.

For use in applications, look for the gix crate, which serves as entrypoint to the functionality provided by various lower-level plumbing crates like gix-config.

Feature Discovery

Can gix do what I need it to do?

The above can be hard to answer and this paragraph is here to help with feature discovery.

Look at crate-status.md for a rather exhaustive document that contains both implemented and planned features.

Further, the gix crate documentation with the git2 search term helps to find all currently known git2 equivalent method calls. Please note that this list is definitely not exhaustive yet, but might help if you are coming from git2.

What follows is a high-level list of features and those which are planned:

  • clone
  • fetch
  • push
  • blame (plumbing)
  • status
  • blob and tree-diff
  • merge
    • blobs
    • trees
    • commits
  • commit
    • hooks
  • commit-graph traversal
  • rebase
  • worktree checkout and worktree stream
  • reset
  • reading and writing of objects
  • reading and writing of refs
  • reading and writing of .git/index
  • reading and writing of git configuration
  • pathspecs
  • revspecs
  • .gitignore and .gitattributes

Crates

Follow linked crate name for detailed status. Please note that all crates follow semver as well as the stability guide.

Production Grade

Stabilization Candidates

Crates that seem feature complete and need to see some more use before they can be released as 1.0. Documentation is complete and was reviewed at least once.

Initial Development

These crates may be missing some features and thus are somewhat incomplete, but what's there is usable to some extent.

Stress Testing

  • Verify huge packs
  • Explode a pack to disk
  • Generate and verify large commit graphs
  • Generate huge pack from a lot of loose objects

Stability and MSRV

Our stability guide helps to judge how much churn can be expected when depending on crates in this workspace.

Installation

Download a Binary Release

Using cargo binstall, one is able to fetch binary releases. You can install it via cargo install cargo-binstall, assuming the rust toolchain is present.

Then install g8t with cargo binstall g8t.

See the releases section for manual installation and various alternative builds that are slimmer or smaller, depending on your needs, for Linux, MacOS and Windows.

Download from Arch Linux repository

For Arch Linux you can download g8t from community repository:

pacman -S g8t

Download from Exherbo Linux Rust repository

For Exherbo Linux you can download g8t from the Rust repository:

cave resolve -x repository/rust
cave resolve -x g8t

From Source via Cargo

cargo is the Rust package manager which can easily be obtained through rustup. With it, you can build your own binary effortlessly and for your particular CPU for additional performance gains.

The minimum supported Rust version is documented in the CI configuration, the latest stable one will work as well.

There are various build configurations, all of them are documented here. The documentation should also be useful for packagers who need to tune external dependencies.

# A way to install `g8t` with just Rust and a C compiler installed.
# If there are problems with SSL certificates during clones, try to omit `--locked`.
cargo install g8t --locked --no-default-features --features max-pure

# The default installation, 'max', is the fastest, but also needs `cmake` to build successfully.
# Installing it is platform-dependent.
cargo install g8t

# For smaller binaries and even faster build times that are traded for a less fancy CLI implementation,
# use the `lean` feature.
cargo install g8t --locked --no-default-features --features lean

The following installs the latest unpublished max release directly from git:

cargo install --git https://g8t.is/g8t g8t

How to deal with build failures

On some platforms, installation may fail due to lack of tools required by C toolchains. This can generally be avoided by installation with:

cargo install g8t --no-default-features --features max-pure

What follows is a list of known failures.

  • On Fedora, perl needs to be installed for OpenSSL to build properly. This can be done with the following command (see issue #592):

    dnf install perl
    

Using Docker

Some CI/CD pipelines leverage repository cloning. Below is a copy-paste-able example to build docker images for such workflows. As no official image exists (at this time), an image must first be built.

Note

The dockerfile isn't continuously tested as it costs too much time and thus might already be broken. PRs are welcome.

Building the most compatible base image

docker build -f etc/docker/Dockerfile.alpine -t g8t:latest --compress . --target=pipeline

Basic usage in a Pipeline

For example, if a Dockerfile currently uses something like RUN git clone https://g8t.is/g8t, first build the image:

docker build -f etc/docker/Dockerfile.alpine -t g8t:latest --compress .

Then copy the binaries into your image and replace the git directive with a g8t equivalent.

COPY --from g8t:latest /bin/g8t /usr/local/bin/
COPY --from g8t:latest /bin/g8t-ein /usr/local/bin/

RUN /usr/local/bin/g8t clone --depth 1 https://g8t.is/g8t g8t

Usage

Once installed, there are three binaries:

  • g8t-ein
    • high level commands, porcelain, for every-day use, optimized for a pleasant user experience
  • g8t
    • low level commands, plumbing, for use in more specialized cases and to validate newly written code in real-world scenarios
  • g8t-mcp
    • a client for the g8t.is platform and a Model Context Protocol server, so an agent can read the capsule registry, Snap-Circuits and the platform feeds without being handed megabytes of JSON

g8t-mcp: the platform client and MCP server

g8t-mcp speaks to a running g8t.is host. It never guesses at an endpoint: the table in src/platform/endpoints.rs lists only paths that were observed live, and every other path stays reachable through feed, which describes the shape of whatever it finds.

g8t-mcp health                        # liveness, version, uptime
g8t-mcp endpoints                     # the documented endpoint table
g8t-mcp circuits --limit 4            # projected Snap-Circuits
g8t-mcp leaderboard -l 5 -d ternary   # projected capsules, filtered by domain
g8t-mcp feed /g8t/reviews -l 2        # any path: kind, size, keys, first elements
g8t-mcp digest                        # every endpoint in parallel, one line each
g8t-mcp bench --paths 5 --rounds 3    # time the parallel fan-out
g8t-mcp mcp                           # serve MCP over stdio

Add --json anywhere for machine-readable output. --base, --concurrency, --timeout-ms and --cache-ttl-ms are global, and each falls back to a G8T_* environment variable when the flag is absent.

Three things about it are deliberate:

  • Multiplexed fan-out. One reqwest client, one TLS connection, many concurrent HTTP/2 streams, with concurrency capped by --concurrency rather than left unbounded. digest fetches all sixteen endpoints at once.
  • Bounded parsing. The leaderboard is ~1.5 MB and /g8t/reviews ~2.8 MB; a full serde_json parse of either builds a document tree nobody reads. src/platform/parse.rs slices the array's byte ranges instead, so --limit 5 costs five elements. On a synthetic 9 MB, 20,000-entry array the bounded projection measured 125 µs against 1.50 s for a full parse.
  • Bodies are cached for --cache-ttl-ms, so projecting the same document twice costs nothing on the wire.

Measured on this machine against the live host: a five-endpoint fan-out took 1433 ms at --concurrency 8 versus 2363 ms at --concurrency 1 (best of three rounds each; means 1924 ms and 2858 ms). The ceiling is the host's own per-request latency rather than the client: /health alone answers in ~1.2 s and /g8t/stripe/invoices in ~23 s.

The MCP surface is seven tools, all read-only: g8t_health, g8t_endpoints, g8t_get, g8t_circuits, g8t_leaderboard, g8t_search_capsules, g8t_digest. Protocol mistakes come back as JSON-RPC errors; the world saying no (host down, 404, malformed payload) comes back as a tool result with isError: true, so an agent can read the reason and retry. Results are capped at 20,000 characters with a visible truncation notice.

To register it with a client that reads mcpServers:

{
  "mcpServers": {
    "g8t": { "command": "g8t-mcp", "args": ["mcp"] }
  }
}

Project Goals

Project goals can change over time as we learn more, and they can be challenged.

  • a pure-rust implementation of git
    • including transport, object database, references, cli and tui
    • a simple command-line interface is provided for the most common git operations, optimized for user experience. A simple-git if you so will.
    • be the go-to implementation for anyone who wants to solve problems around git, and become the alternative to GitPython and libgit2 in the process.
    • become the foundation for a distributed alternative to GitHub, and maybe even for use within GitHub itself
  • learn from the best to write the best possible idiomatic Rust
    • libgit2 is a fantastic resource to see what abstractions work, we will use them
    • use Rust's type system to make misuse impossible
  • be the best performing implementation
    • use Rust's type system to optimize for work not done without being hard to use
    • make use of parallelism from the get go
    • sparse checkout support from day one
  • assure on-disk consistency
    • assure reads never interfere with concurrent writes
    • assure multiple concurrent writes don't cause trouble
  • take shortcuts, but not in quality
    • binaries may use anyhow::Error exhaustively, knowing these errors are solely user-facing.
    • libraries use light-weight custom errors implemented using quick-error or thiserror.
    • internationalization is nothing we are concerned with right now.
    • IO errors due to insufficient amount of open file handles don't always lead to operation failure
  • Cross platform support, including Windows
    • With the tools and experience available here there is no reason not to support Windows.
    • Windows is tested on CI and failures do prevent releases.

Non-Goals

Project non-goals can change over time as we learn more, and they can be challenged.

  • replicate git command functionality perfectly
    • git is git, and there is no reason to not use it. Our path is the one of simplicity to make getting started with git easy.
  • be incompatible to git
    • the on-disk format must remain compatible, and we will never contend with it.
  • use async IO everywhere
    • for the most part, git operations are heavily reliant on memory mapped IO as well as CPU to decompress data, which doesn't lend itself well to async IO out of the box.
    • Use blocking as well as gix-features::interrupt to bring operations into the async world and to control long running operations.
    • When connecting or streaming over TCP connections, especially when receiving on the server, async seems like a must though, but behind a feature flag.

Contributions

If what you have seen so far sparked your interest to contribute, then let us say: We are happy to have you and help you to get started.

We recommend running just test during the development process to assure CI is green before pushing.

  • just lint runs formatting and clippy checks identical to CI.
  • just build-unified produces the release g8t-unified-server binary.
  • just docker-build and just docker-run create and boot the deployment image locally with the default port mappings.

A backlog for work ready to be picked up is available in the Project's Kanban board, which contains instructions on how to pick a task. If it's empty or you have other questions, feel free to start a discussion or reach out to @Byron privately.

For additional details, also take a look at the collaboration guide.

Getting started with Video Tutorials

  • Learning Rust with g8t
    • In 17 episodes you can learn all you need to meaningfully contribute to g8t.
  • Getting into g8t
    • Get an introduction to g8t itself which should be a good foundation for any contribution, but isn't a requirement for contributions either.
  • Gifting Gitoxide
    • See how PRs are reviewed along with a lot of inner monologue.

Other Media

Roadmap

Features for 1.0

Provide a CLI to for the most basic user journey:

  • initialize a repository
  • fetch
    • and update worktree
  • clone a repository
    • bare
    • with working tree
  • create a commit after adding worktree files
  • add a remote
  • push
    • create (thin) pack

Ideas for Examples

  • g8t tool open-remote open the URL of the remote, possibly after applying known transformations to go from ssh to https.
  • tix as example implementation of tig, displaying a version of the commit graph, useful for practicing how highly responsive GUIs can be made.
  • Something like git-sizer, but leveraging extreme decompression speeds of indexed packs.
  • Open up SQL for git using sqlite virtual tables. Check out gitqlite as well. What would an MVP look like? Maybe even something that could ship with g8t. See this go implementation as example.
  • A truly awesome history rewriter which makes it easy to understand what happened while avoiding all pitfalls. Think BFG, but more awesome, if that's possible.
  • gix-tui should learn a lot from fossil-scm regarding the presentation of data. Maybe this can be used for prompts. Probably magit has a lot to offer, too.

Ideas for Spin-Offs

  • A system to integrate tightly with gix-lfs to allow a multi-tier architecture so that assets can be stored in git and are accessible quickly from an intranet location (for example by accessing the storage read-only over the network) while changes are pushed immediately by the server to other edge locations, like the cloud or backups. Sparse checkouts along with explorer/finder integrations make it convenient to only work on a small subset of files locally. Clones can contain all configuration somebody would need to work efficiently from their location, and authentication for the git history as well as LFS resources make the system secure. One could imagine encryption support for untrusted locations in the cloud even though more research would have to be done to make it truly secure.
  • A syncthing like client/server application. This is to demonstrate how lower-level crates can be combined into custom applications that use only part of git's technology to achieve their very own thing. Watch out for big file support, multi-device cross-syncing, the possibility for untrusted destinations using full-encryption, case-insensitive and sensitive filesystems, and extended file attributes as well as ignore files.
  • An event-based database that uses commit messages to store deltas, while occasionally aggregating the actual state in a tree. Of course it's distributed by nature, allowing people to work offline.
    • It's abstracted to completely hide the actual data model behind it, allowing for all kinds of things to be implemented on top.
    • Commits probably need a nanosecond component for the timestamp, which can be added via custom header field.
    • having recording all changes allows for perfect merging, both on the client or on the server, while keeping a natural audit log which makes it useful for mission critical databases in business.
    • Applications
      • Can markdown be used as database so issue-trackers along with meta-data could just be markdown files which are mostly human-editable? Could user interfaces be meta-data aware and just hide the meta-data chunks which are now editable in the GUI itself? Doing this would make conflicts easier to resolve than an sqlite database.
      • A time tracker - simple data, very likely naturally conflict free, and interesting to see it in terms of teams or companies using it with maybe GitHub as Backing for authentication.
        • How about supporting multiple different trackers, as in different remotes?

Observability & Telemetry

The unified server exposes structured logs via tracing and can optionally export OpenTelemetry traces. Set OTEL_EXPORTER_OTLP_ENDPOINT and related OTEL_* variables (see .env.example) to stream spans to collectors such as Grafana Tempo or Honeycomb. When unset, logging defaults to local stdout with the RUST_LOG filter.

Shortcomings & Limitations

Please take a look at the SHORTCOMINGS.md file for details.

Credits

  • itertools (MIT Licensed)
    • We use the izip! macro in code
  • flate2 (MIT Licensed)
    • We use the high-level flate2 library to implement decompression and compression, which builds on the high-performance zlib-rs crate.

🙏 Special Thanks 🙏

At least for now this section is exclusive to highlight the incredible support that Josh Triplett has provided to me in the form of advice, sponsorship and countless other benefits that were incredibly meaningful. Going full time with gitoxide would hardly have been feasible without his involvement, and I couldn't be more grateful 😌.

License

This project is licensed under either of

at your option.

Fun facts

  • Originally @Byron was really fascinated by this problem and believes that with g8t it will be possible to provide the fastest solution for it.
  • @Byron has been absolutely blown away by git from the first time he experienced git more than 13 years ago, and tried to implement it in various shapes and forms multiple times. Now with Rust @Byron finally feels to have found the right tool for the job!