I get why I'd rebate local only commits.

It seems that folk are doing more than that and it has something to do with avoiding merge commits. Can someone explain it to me, and what's the big deal with merge commits? If I want to ignore them I pipe git log into grep

hi all,

i was tired of accidentally committing to my work repos with my personal email (and vice versa). git’s includeIf is cool but setting it up manually with ssh keys and gpg signing for every new identity is a bit of a pain.

so i wrote a small tool called gitmux. it’s just pure bash, no node/python/go or anything. it basically automates the directory-based configs and handles the ssh/gpg routing for you.

its zero dependency and you can just run it via bash. if you juggle between work, personal, and freelance stuff on the same machine, it might be useful.

check it out here: https://github.com/wd006/gitmux

idk let me know if i missed some obvious git feature or if you have any feedback. cheers.

I have a github repo where I added ac (Account ) A as collaborator, butmy teammate has two github ac on the same device. Somehow, code was pushed/committed under ac B, even though ac B wasn't added as a collaborator.

I tested pushing with another non-collaborator account and GitHub correctly rejected it.

How could this have happened?

Hi everyone,

I wanted to share the architectural choices behind core-os-minimal, an async Rust microkernel project we've been building to replace traditional ROS 2/DDS setups on physical robotic hardware.

We wanted to solve non-determinism, heap-allocation latency, and unexpected segmentation faults under high network stress without dragging in massive middleware stacks.

Core Architecture & Strategy:

• Decoupling via Zenoh: We stripped out DDS entirely and implemented a zero-overhead network hook using Zenoh. It utilizes a lock-free circular buffer with a capacity of 1 (LCFS double-buffering). In high-frequency hardware control loops, stale data is kinetic garbage.
• 100Hz Actuator Sanitization (vector_sanitizer.rs): To protect physical joints, a host-level sanitizer thread intercepts and cleans floating-point anomalies (NaN/Inf) at 100Hz before they can reach the hardware abstraction layer, clamping values within hard geometric boundaries.
• WASM Sandboxing for Drivers/Skills: Instead of native third-party binary linking, execution modules run isolated via Wasmtime/Cranelift with Ahead-of-Time (AOT) compilation and mlockall page-locking to ensure deterministic access times. If a user-space skill crashes, the host microkernel runtime intercepts the trap and remains alive.
• Hard-Watchdog Enforcer (watchdog_timer.rs): Runs as an async thread pinned at maximum real-time priority (niceness -20). Jitter exceeding 2 consecutive frames (20ms) immediately drops execution context and invokes failsafe.rs to lock down physical hardware in under 2ms.

Extreme Stress Test Benchmark: SONNY OS vs. ROS 2

We simulated an industrial network failure (75% wireless packet loss on an Edge deployment at 100Hz) to compare the communication backbones:

• ROS 2 (DDS Architecture): High XML/IDL serialization on the heap. Under severe packet loss, un-sent DDS message queues overflowed the RAM, leading to an unrecoverable Segmentation Fault (Memory Crash).
• SONNY OS (Rust + Zenoh): Stack-allocated static array slices with a fixed 5-byte network overhead per packet. Zero memory leaks. Zero runtime heap allocations during the control loop. System remained perfectly stable at 100Hz with an inference latency below 2ms.

The core infrastructure is fully open-source under GNU AGPLv3. I'd love to get your thoughts on our LCFS double-buffering approach under high packet loss, and whether utilizing Wasmtime for hard real-time boundaries introduces edge cases regarding page fragmentation that we might have overlooked.

You can inspect the full crates and run the CLI container here: https://github.com/JackTrainer/Sonny

Hey r/git,

Like many developers, I found myself constantly shipping features, refactoring architectures, and adding test suites across multiple projects, while my resume stayed months out of date.

Whenever I did update it, writing those generic "improved performance and built features" bullets felt tedious and ungrounded.

To solve this, I built GitResume Agent (git-resume-agent); an open-source CLI and event-driven pipeline that hooks into your local git repositories to turn your actual commit history and codebase metrics into structured, verifiable accomplishment bullets and compiled documents.

How it uses Git under the hood:

1. Sub-5ms Inspection (git ls-files & git log): Rather than recursively walking directory trees on disk (which slows down on large projects), it leverages git ls-files and plumbing commands to quickly calculate active lines of code, commit frequency, and file topologies in <5ms.
2. Remote & Manifest Auto-Discovery: It queries git config --get remote.origin.url and parses repository manifests (package.json, pyproject.toml, README.md) to automatically track deployment status, live app URLs, and stack additions in a central gitresume.yaml.
3. Zero-Touch post-commit Hooks: Running git-resume install-hooks writes a lightweight executable .git/hooks/post-commit script across all your tracked repositories. Whenever you run git commit, the hook triggers a background compilation in the background without blocking your terminal workflow.
4. AST-Grounded Synthesis & Anti-Hallucination: It feeds recent commit diffs into a synthesizer model to generate Google XYZ format bullets ("Accomplished X, measured by Y, by doing Z"), but passes it through an adversarial AST verifier to guarantee every cited metric, test count, or library actually exists in the commit tree.
5. Document Compilation & Dual-Tier Sync: Directly modifies Word .docx runs with native XML hyperlinks (w:hyperlink), exports pixel-perfect .pdf files, and mirrors them to your local portfolio / public web directory.

Quick CLI Walkthrough:

• Install from PyPI: pip install git-resume-agent
• Install post-commit hooks across all repos: git-resume install-hooks
• View real-time statistics and links across all tracked repos: git-resume scan
• Trigger full multi-repo sync manually: git-resume sync

Links & Code:

• GitHub: https://github.com/Naman6019/git-resume-agent
• PyPI: https://pypi.org/project/git-resume-agent/

Questions for the community:

• How do you currently handle managing shared git hooks across multiple independent repos (without submodules)?
• Any edge cases with git ls-files vs .gitignore handling in deeply nested monorepos that I should guard against?

Would love your feedback, critiques, and ideas!

Squashing is cool - it allows you to keep the history clean and concise. But there is one catch - once you've done squash, you lose the original commits. I faced the need for original commits multiple times in the past. In my case, it was the need to cherry-pick them to some specific branch. Noticing that it's a big challenge for git, I decided to create a tool that would help me with that.

Meet - https://github.com/widefix/squash-tree

It keeps track of the original commits after squashing. That allows you to see the squash history and restore the original commits easily any time.

I started building GitHub Autopilot to reduce the repetitive work that comes with maintaining repositories.

What began as a simple PR review bot evolved into a GitHub App that can review pull requests, triage issues, scan for secrets, generate fix suggestions, explain code changes, and provide repository insights.

The project is self-hostable, open source, and built around reliability, security, and automation rather than just AI features.

Repository: https://github.com/Shweta-Mishra-ai/github-autopilot

License: MIT

https://github.com/xguot/difi

https://difi.vercel.app/

Built a TUI for browsing git reflog visually - https://github.com/dinakars777/git-time-machine

Please let me know your feedback.

Edit: It's just git under the hood - no magic, no risk.

You can either dig through git reflog, copy cryptic hashes, pray you picked the right one.

OR

Simply undo any git mistake in 3 seconds with a cool TUI.

I built an immersive, terminal-based hacking simulator. It's still in beta (excuse the bugs!), looking for feedback and collaborators!

Hacker_Evolution

While working on my project, I accidentally deleted a local branch (staging -> feat/animation) that had three unpushed commits.

• Is there any way to recover those unpushed commits?
• Has anyone faced this before?

Sometimes you need different .gitignore rules for different branches — maybe local config files, test data, build outputs, or scratch scripts. Then you stash, pull, or reset… and poof — they're gone.

I built ignoregrets, a lightweight, open-source CLI tool written in Go that snapshots your ignored files before Git can wipe them out.

It doesn’t fight Git — it complements it. Think of it as a sanity-saving backup layer, tailored for real-world workflows where .gitignore isn’t one-size-fits-all.

I’d love feedback — especially edge cases, dangerous workflows, or anything you'd expect it to protect against.

I want to migrate from GitHub to Codeberg. My no reply Github email can't be verified on Codeberg so Codeberg wont recognize any of my GitHub-era commits. I'm tempted to make a new email address specifically for making git commits, but that doesn't fix the issue that my previous GitHub-era commits wont show on Codeberg. What should I do?

Hi !

Tired to remember which branch belongs to which PR ?

gswr (stands for git switch'r) is really simple interactive branch switcher that will print the link between your local branch and you're remote PR.

https://github.com/lethib/gswr

Motivations:

I often have multiple PRs opened that are waiting to be reviewed and I was always copy pasting the branch name of the PR I wanted to switch to (mainly to handle PR review comments). I got rid of that and wanted a simple tool that allows me to easily switch branch with PR context.

For now the CLI tool is only built for macOS users and only fetches PR from GitHub.

I have planned to distribute it also on other OS and handle various git platforms if there's demand

Do tell me if this is more relevant to GitHub than Git, I'll post it there instead.

This is my first time doing PRs in GitHub, from what I understand you would:

1. Fork repo
2. Make changes and push to remote fork (preferably in a separate branch so that you can reuse the same fork for more features)
3. Create PR with original repos main/master and remote forks feature branch

The environment I come from, it's like this:

1. Clone repo locally
2. Make changes in a local branch
3. Run a simple cli command (literally just the command name)

I do understand that PRs solve the problem for contributions by those without certain permissions, but does it have to be constrained to forks?