nerdypepper

web-of-trust models can help https://blog.tangled.org/vouching/

rendering massive diffs is cool but ultimately a gimmick. in what scenario are you actually reading a 500k line diff?

something i'd really want to see from forges is alternate diff techniques: like AST diffing.

> Well Y Does Some Of That

yes but tangled.org really does do most of that!

1. JJ as the VCS: tangled supports stacked PRs using jj change-ids. https://blog.tangled.org/stacking , we use it a lot to build tangled itself: https://tangled.org/tangled.org/core/pulls

2. Raspberry pi as a forge for a long time: also check, the git server shim is super lightweight, its just an XRPC layer over git repositories + an sqlite3 database. there are folks running it on a riscv board with 512 megs of RAM.

3. Actions are critical and they should be runnable on my local machine: IMO this ask is slightly misplaced. it is mostly your build-systems' job to be hermetic, run anywhere, handle cross-builds etc. it would be really cool to "promote" results of such builds to the forge itself.

i am unable to access any repository on that website. for some, it complains that ssh or https URLs are not supported by my browser? and for others its just loading indefinitely with `Failed to load file tree`. maybe its not fairly mature.

> gpg keys; if someone has your private key, they are you no matter where

how would you rotate such a key and still convince everybody that you are still you?

> Or in other words, what specifically does GitHub "do" that can't be done by using git as a backing store?

how would you build a social graph of follows/stars and what not using user-owned git repos as a backing store?

> But federated authorization is one of the things ActivityPub doesn't define, and leaves it to us to figure out.

this is the key bit, atproto has this. sidecar services like knot can use service authentication[0] for authenticated requests.

[0]: https://atproto.com/guides/auth

its linked in the original post as well, but here is an explanation of why activitypub is not a good fit for this problem, by the authors of ForgeFed themselves: https://forgefed.org/blog/actor-programming/

maybe, but tangled knots actually federate. you could contribute to repos on knot.ghostty.org and knot.tangled.org with the same account. no other platform permits one identity across instances.

give tangled.org a go perhaps. its got the self-hostability that cgit/forgejo does and a the social bits that github does.

tangled.org maybe?

yes, thats right! when you submit a branch, you can choose to "stack" it, so the individual commits in the branch turn into separate PRs. these PRs evolve individually, can be merged individually, and be reviewed individually. you can also set different reviewers/labels for different PRs in the stack.

https://tangled.org does exactly what you want :)

have a longer write up here: https://blog.tangled.org/stacking but we have "interdiffs", to view a delta from previous review. pull-requests advance in the form of immutable rounds much like the patch workflow on email.

we have been interdiffing and stacking for a while on to dogfood, sample PR: https://tangled.org/tangled.org/core/pulls/1265/round/1?diff...

we have been stacking on tangled.org for a while now, you can see a few examples of stacks we have made here: https://tangled.org/tangled.org/core/pulls?state=merged&q=st...

for example, this stack adds a search bar: https://tangled.org/tangled.org/core/pulls/1287

- the first PR in the stack creates a search index.

- the second one adds a search API handler.

- the last few do the UI.

these are all related. you are right that you can do this by breaking a change into commits, and effectively that is what i do with jujutsu. when i submit my commits to the UI, they form a PR stack. the commits are individually reviewable and updatable in this stacking model.

gh's model is inherently different in that they want you to create a new branch for every new change, which can be quite a nuisance.

have written more about the model here: https://blog.tangled.org/stacking/

tangled.org supports native stacking with jujutsu, unlike github's implementation, you don't need to create a new branch per change: https://blog.tangled.org/stacking/

y'all gotta throw this up on https://tangled.org ;)

relatedly, i have been using literate haskell to document my advent of code journey this year:

- day 5's solution for example: https://aoc.oppi.li/2.3-day-5.html#day-5

- literate haskell source: https://tangled.org/oppi.li/aoc/blob/main/src/2025/05.lhs

the book/site is "weaved" with pandoc, the code is "tangled" with a custom markdown "unlit" program that is passed to GHC.

how is atuin doing what deltaDB does?

no AP is not the right protocol for shared/collaborative systems, the creators of forgefed have the same thoughts: https://forgefed.org/blog/actor-programming/.

https://tangled.sh?

social features via atprotocol, native jujutsu support, stacked PRs, interdiffs, light weight to selfhost, nix-based CI.

there's https://forgefed.org/ defined by the creators of forgejo. there is no complete implementation of the spec. from the last forgejo changelog, the "star" action has been completely federated. federated PRs and issues are a long way away.

https://tangled.sh is the other contender in this space that I know of. uses atproto (same as bluesky) under the hood.

fundamentally activitypub is insufficient to define these kind of networks. you'd need to have some sort of object-capability representation. the creators of forgefed are also moving in this direction: https://codeberg.org/Playwright/playwright

the only thing I really miss from GitHub is the social bits. it's super easy to stand up cgit etc. but you miss out on actual collab features, discover etc.

I've moved the bulk of my repos from GitHub to cgit first, but now to https://tangled.sh.