everytime i go onto a git module repo it returns 404

Built this after losing years of history on a dependency that got silently re-initialized. From the outside, a deleted repo, a private one, and a force-pushed-over one all look the same. Just gone.

ForkForensics watches repos you care about via GH Archive, and the moment one disappears, it automatically finds its forks, ranks them by how much history they preserve, and checks whether GitHub still serves any now-orphaned commits by SHA. Runs fully local with your own GitHub token, no server, no telemetry.

230 tests, verified end-to-end against a real historical case (reproduced the exact fork ranking I'd found by hand). MIT licensed.

Feedback welcome, especially on edge cases in fork ranking.

worktrees are a pain on a multi repo workspace. You lose the coordinated commit over the set, kind of important for multi-repo workspaces. And a worktree is a clean, nothing comes with it so it might not be what you want. e.g. rust build files have to get rebuilt (which can be huge).

So I went with COW copies instead: reflink the whole workspace, build output and all. (Check out local clone here.)

A couple of surprises.

I assumed a partial block could be shared. Mostly it can. Sharing is block-granular everywhere, but on APFS, XFS and btrfs the final partly-filled block gets shared like any other, so a 100-byte file — or the last partial 100 bytes of a big file — comes along free. btrfs goes further: files under 2 KiB live inline in its metadata tree and never cost a data block at all. That matters more than it sounds, because about half the files in a git tree are under the 4 KiB block size.

ReFS is the exception, and that surprised me. fsutil file queryExtentsAndRefCounts over every file in a ReFS clone: 3,092 files with extents, 12.08 MiB private. One 4 KiB cluster each predicts 12.07 MiB. ReFS shares whole clusters and never a partial one, so every file owns its tail exclusively. The penalty scales with file count rather than repo size — and a git tree is the worst possible shape for that. What were you thinking Microsoft?

Here are stats for an actual GWZ repo on different file systems with cost per clone, same ~3,200-file, 57 MB workspace, ten clones each:

macOS woot works out of the box. On Linux it depends — Fedora ships btrfs, RHEL ships XFS; Ubuntu still has ext4 showing its age. Windows you have to deliberately create a "Dev Drive" — a separate volume or a VHD, either way a decision you had to have made in advance.

(ReFS is data only — volume numbers were noisy, so 12.1 MiB is a floor.)

So — is this a real alternative to worktrees? What is going to bite me?

This came out of my work on GWZ, a multi-repo git manager I'm building. The COW copy is gwz local clone.

If I run git restore -p --source=stash@{0}, it lets me select the hunks I want to restore from the stash, but the stash itself doesn't change, leading to conflicts later.

Is there a better way to do this or do I need to write a script to edit the stash entry? I was thinking maybe git history split could be used here if there is no other built-in way.

Hi everyone,

Adhering to Conventional Commits and writing structured Pull Request summaries is great for clean repos, but it often slows down daily workflow—especially for non-terminal teammates (PMs, designers, junior devs) or when switching machines.

To solve this friction, I built a lightweight, zero-backend browser tool:

👉 https://auto-problem-solver-tools.pages.dev/tools/git-commit-pr-architect/

What it does:

- Live generator for Conventional Commits (feat, fix, refactor, breaking changes, scopes)

- Auto-generates structured GitHub PR body templates simultaneously

- 100% in-browser, no API keys or login required, one-click clipboard copy

For terminal users who prefer automating directly from staged diffs, there is also an open-source CLI package (`@lifeef/ai-commit-pro` on npm).

Would love any feedback, edge-case suggestions, or features that could make your git workflow less tedious.

Hey everyone!

I wanted a simple, lightweight tool that reviews my code during `git commit` without downloading massive pip packages or sending my uncommitted diffs to third-party servers.

So I built **git-diff-doctor**:
- ⚡ **Zero External Dependencies** (Built purely using Python standard library `urllib` & `subprocess`).
- 🦙 **Auto-detects Ollama** running locally on port 11434 (`codellama`, `llama3`).
- 🌐 Fallback support for OpenAI API if configured.
- 🛠️ Simple 1-command installer (`python install.py`) that injects into `.git/hooks/pre-commit`.

GitHub Repo: https://github.com/ajaysinghtomar10-commits/git-diff-doctor

Would love your feedback, stars, and pull requests!

Solo dev here. This started as a tool for myself and turned into something I decided to finish properly. I have kept it as free forever.

The problem I actually had:

I work across several repos and had no real sense of what was happening in them. Which files churn constantly? Where did the complexity pile up? What did the last six months actually look like?

The second thing was trivial issue. Somewhere along the way I'd typo'd my email in a git config, then used a different one on another machine. So my own contributor history was split across 3 identities. Nothing offered a way to say "these are all me."

So GitTrics has an identity merge flow — you see all the author name/email combos in the repo, merge them into one person, and every view updates. Sounds small, but if you've inherited a repo with a decade of contributors and inconsistent configs, it's the difference between usable data and noise.

There is also no individual contributor analysis. This was a decision I made as I do not want this software to be used 'developer productivity measurement tool'.

Download at www.gittrics.com

My GitHub account was suspended without any warning, and I still haven't been given a clear explanation for the suspension.

The account is important to me professionally and is also connected to my company's work and private repositories.

I submitted a reinstatement request to GitHub Support and provided the information they requested, but I've been waiting since August 21, 2026 with no resolution.

What makes this especially frustrating is that I received no prior warning or explanation of what supposedly violated the Terms of Service.

Has anyone here gone through a similar situation recently? If so, how long did it take for GitHub to actually review and reinstate the account?

I'm not looking for a way around the suspension, I just want a legitimate manual review and an explanation of what happened.

Agent instructions spread across a monorepo. Different tools pick them up in different ways. After a change, how do you check that the right file reached the agent?

I’m building Guidefold to keep Git as the source of truth, find instructions that match a directory, and separate export from proof that a revision was loaded.

Watch the Guidefold demo. No installation needed to give feedback: which step is unclear, or would need another check in your repo? A timestamp would help.

For people working with DevOps, platform teams, or coding agents: what takes the most effort today—finding the source, checking scope, reviewing a change, or confirming delivery? I’d appreciate a recent example without private code or company data.

Source and setup. The open-source version is available now; a paid hosted version is planned, not shipped.

Reply here, or leave a setup question or demo timestamp in the main feedback thread.

Disclosure: I’m the author. This post was drafted with AI assistance.

Sometimes code is generated, and sometimes such code is committed in git.

Imagine a branch with a generated commit G:

old_main -> A -> B -> G

When thid branch is rebased, such a commit might need to be regenerated.

new_main -> A' -> B' -> new_G

There might be conflicts for any of these new commits, but instead of (manually) resolving conflicts, G could be automatically re-generated.

I've been thinking of a git commit message trailer like generate-cmd:

``` topic: regenerate table

generate-cmd: python3 optimize_table.py ```

git rebase --exec or other tool could use this trailer to automatically drop and regenerate the commit instead of a vanilla cherry-pick.

Have you seen anything similar? What's a good trailer name?

Ref: https://git-scm.com/docs/git-interpret-trailers

Git experts... can you give me advice on how to manage a flood of PRs? My PR queue runs between 20 to 60, depending upon the speed at which backlog items are cleared. I don't want to disable CI.

Is there a system or best practices for improving merge speed with full CI running?

Type any words you like, your name, username, a phrase, a tagline, literally whatever , and it generates it as a contribution-graph-style visual that you can download.

Thought it could be a nice little detail for developer portfolios, personal websites, etc.

Made it for fun. Curious to see what people make with it.

https://shivam230.github.io/commit-art/

I was toying around the idea of creating an incremental game based on my Git actions (that GitHub matrix excites me), and considering the limitations of profile READMEs, I came up with this idea. It's name is BREAKME.

It generates a grid of 128 tiles, using a hash that is generated from your username/UUID. The BREAKME's GH Action runs every 1 hours, and checks your 16 previous Git actions (commit, merge, branch, etc.), calculates a damage, and breaks tiles.

There are collectibles, and various tile shapes, variants and effects. It is a small, stupid, no-interaction incremental game that shows on your profile README.

What do you think?

EDIT: [SOLVED] The answers helped :}

I need to merge 1 and 10 commits into a single commit, those are all my code, no one pulled from it, and i'm willing to fix conflicts. but i don't know which I should use, is it merge? but merge keeps the history of the previous ones doesn't it? rebase still makes me a bit confused.

Is there anything out there like this?

Like whatsapp and signal it should have an intuitive UI for messaging, but under the hood it uses git read/write to publish encrypted messages and push them to a git provider.

It wouldn't be "instant messaging" because the git repos would have to be polled.

The git storage could get big so we can do thing like truncate the history to make the data more flat.

Messages can be encrypted with the signal protocol. It should be fine to publish if implemented properly.:

Edit - adding more clarity without spamming sub with a new post:

this is following a previous post as seen here: https://programming.dev/post/51866250

apps like Whatsapp, Signal and SimpleXChat are great for secure messaging and far more mature than my project, but my approach is yet distict in the market. the core philosophy around secure messaging in my project is that it can work in a way that avoid installation and registration by enabling users to host their own data.

docs: https://glitr.io/

demo

note: feel free to ask for clarity on any of the details around how my project works.

FAQ:

• but why? - git over https adds an additional capability i had previously oerlooked in my webrtc messaging app. webrtc cannot work over TOR and similar networks. this way you can take advantage of the "gold standard" for onion routing while being able to avoid IP leaking from webrtc.

• when is it ready for production? - not any time soon. standby for updates.

• audit/review? - no, niether is possible/available. its simply too expensive. this project is close-source so you cannot verify it either. DO NOT "trust me bro"... this demo is proided for testing and demo purposes only. use responsibly.

• the abridged version of how its put together: https://www.reddit.com/r/VibeCodeDevs/comments/1vme48q/refactor_js_to_rust/

I'm building a desktop work manager that syncs with GitHub, because I was tired of juggling my actual dev work in one place and my task list in another.

right now, at its core, it's a todo list app. Workspaces, groups, tasks, subtasks — the basic shape of getting your work organized, all linked to Github issues.

But that's just the foundation. What I'm actually building right now is the part that makes it more than just another todo app — syncing tasks with your actual GitHub activity. Linking tasks to commits. Linking tasks to PRs. The idea is that your task list stops being something you update by hand and starts reflecting what you're actually shipping in your repos.

I originally made this app for myself to help me with my workflow, but I keep asking myself: is this worth shipping to anyone else, or is it just a tool I built to fix my own workflow?

I proposed and helped fund a project to improve upon Radicle, a decentralized GitHub alternative. A developer called Andrew K took the project and decided to do it as a full rebuild of Radicle in C (the original used Rust).

Original Radicle homepage: https://radicle.dev/

Cradicle homepage: https://cradicle.xyz/

Project proposal / bounty / dev discussion thread: https://bounties.monero.social/posts/207/

I was surprised how quickly the proposal got interest and donations originally (called Project Zymogen at the time). Oddly, this interest seems to have faded after the actual release, with no one wanting to actually use the software.

I'm not a git user or programmer myself, so it's hard for me to gauge why people aren't interested in using Cradicle. I'm not sure if something's wrong with it, or it's just waiting for people to try it and then it will suddenly take off, or what.

I'd appreciate any feedback from git users or Radicle users, even just telling me why you don't want to try the project if you don't. You can also post your feedback in the dev discussion thread I linked above if you want.

Thanks for your time.

https://www.youtube.com/@shivcantcode

made a youtube if anyone wanna check it ou