Not really related but I find interesting to mention ForgeFed, which is an activitypub extension to do decentralized project discovery.

https://forgefed.org/

I agree that this does not solve the problem right now which you describe as “faking Github so people are not afraid”. It’s mostly: “invent something new to make Github looks not cool anymore”.

Also, reading your txt blog since quite a long time, I’m curious about your thought on Gemini. You seem to share a lot of values with Gemininauts (like myself). A few have also started to tackle the problem of having a Forge on Gemini. And your blog would be completely at home on Gemini (or maybe best on Gopher as you seem to like to force your own line lengths ;-) )

My current setup uses git daemon but this alone isn’t enough. It’d be really nice if there were a git command that could do all the administrative work to put your local git repo to a remote host and “invert” the source of truth to the remote end.

That is actually my favorite feature of sr.ht. If you run:

git remote add origin git@git.sr.ht:~username/my-new-project
git push --set-upstream origin main

their server output will tell you that you just pushed to a repository that doesn’t yet exist, they’ll save your changes for the next 20 minutes, and it prints a URL you can visit to make it permanent.

Having that command has removed almost all the friction in sharing repositories (for me).

I’d keep an eye on Forgejo, it looks like there was a falling out between the maintainers and the business folks or something like that.

I checked out your profile just now, to see if you some how link a way to your code in a way that doesn’t involve a web browser: you don’t.

But I do! Every repository URL on my forge is a cloneable repo. Whenever I link to any of them, they’re both cloneable directly, and when viewed from a browser, they show my Forge’s web view. Judging by my logs, most visitors hit my forge directly at the various project repos, very rarely anywhere else.

But even if they land anywhere else, my forge has an API. Every single page on my forge has a link to the API docs in the footer, too.

How am I expected to have discovered this without a web browser?

You can search all public users with the API:

❯ curl -s 'https://git.madhouse-project.org/api/v1/users/search?q=algernon' \
  | jq -r '.data[].username'
algernon

How am I expected to look at these projects without a web browser?

You can list my (public) repos with the API! And the response even includes a clone URL:

❯ curl -s 'https://git.madhouse-project.org/api/v1/users/algernon/repos?limit=1' \
  | jq -r '.[].clone_url'
https://git.madhouse-project.org/algernon/ErgoDox-sketch.git

And you can do a whole lot more:

You can look at the files in a repo:

❯ curl -s 'https://git.madhouse-project.org/api/v1/repos/algernon/telchar.org/contents' \
  | jq -r '.[].path'
.dir-locals.el
.envrc
.gitignore
.gitmodules
.sops.yaml
COPYING
README.org
config.toml
flake.lock
flake.nix
org
patches
scripts
secrets
themes
tools

You can even look at files!

❯ curl -s 'https://git.madhouse-project.org/api/v1/repos/algernon/telchar.org/contents/README.org' \
  | jq -r '.content' | base64 -d
# the actual contents of README.org

…and you don’t need to check out the repository! You can discover a whole lot about it, before you clone it. You can read the README, and see if its something interesting, and then clone it. Can save you a lot of time and bandwidth! All without a browser, without needing to clone the repo. Just curl, jq, and coreutils.

There’s a whole lot more the API lets you do, without any browser involvement at all. You can open issues, PRs, you can comment on either. You can check the status of CI runs, look at branches, releases, release notes, tags, and what have you. Some of those require an account - but even that is optional. You can opt to not use my forge to report an issue or send a PR. You can email me, too. My email is in the commit messages, and probably in the docs too, not very hard to find. This way, you don’t need an extra account on a random forge (though, Forge Federation will help a lot in that regard in the - hopefully - not too distant future!), and after discovering the API, no browser either.

Can your Shed do the same? Can I browse contents of your repos, without cloning them, to discover more about them? If I can’t discover anything but the name of a repo, I’m not going to bother cloning it. If your Shed provides that on a web UI, then you need a browser to discover more about any given repo, while my forge provides an API, to do it browserless.

There are some great tooling built on top of these APIs, very good IDE integrations. No browser involved.

You don’t even need a browser to discover what the API can do, by the way! The entire API - including its documentation - is available in a neatly packed Swagger JSON! It’s not very human-friendly, but it’s readable. And even better: there is tooling to work with swagger/openapi-based APIs! Tools that can generate API clients based on this JSON, so you can work with it from your favourite programming language, and create the integrations you want. Tools that can generate documentation that you can read, in a format you want.

There may even be existing API clients for your language! For example, the Gitea Go SDK is an official library for the API, for the Go language! And there’s plenty more, if code generation isn’t your cup of tea.

So, basically, the only thing you need to know about my forge to be able to use it without a browser is that it’s a Forgejo instance, which is a Gitea fork, so you can use any kind of tooling available for Gitea. I suppose I could make that more obvious, like, include it in a HTTP header or something.

With that said, every single page on my forge has both the “Powered by Forgejo” link, and a link to the API in its footer. I think that’s fairly discoverable, so you only ever need 1 visit to my site with a browser.

Unfortunately, to browse the online API, you do need a JavaScript-enabled browser. But once you discover it’s Forgejo/Gitea, you don’t even need the online API browser. So, lynx, or even curl works fine, if you know what you’re looking for:

❯ lynx -dump https://git.madhouse-project.org/ | grep -E '/api|forgejo.org'
   3. https://forgejo.org/docs/latest/
 104. https://forgejo.org/
 106. https://git.madhouse-project.org/api/swagger

So, pretty much the same requirements as discovering your code.xml, and your Shed, except my forge provides a whole lot more, and shares the API with any other Gitea and Forgejo instance, and has API libraries in a lot of languages, a lot of IDE integrations, CLI clients, and so on.

A lot of devs only use GitHub / GitLab / etc web UI too. I would say half the time is spent rebasing, commiting in their IDEs/Terms, and the other half PR commenting.

…all of that can be done from the comfort of one’s IDE. Modern IDEs have very good integrations. No need to use the GitHub web UI to comment on PRs. I can do that from within my IDE. Both with GitHub, and with my Forgejo/Gitea instance. No browser involved, my Emacs works fine without one.

GitHub, GitLab, Gitea, Forgejo, and SourceHut all have powerful APIs, with which you can do pretty much everything, without a browser. The browser is only a requirement to discover the API, a requirement shared with your Shed idea.

There are currently no “source sheds” at all. I’m more than glad if you’re aware of not just one but many :) Please share with us!

Lets see… if you want something that doesn’t require a web browser: bare git repos on a webserver work quite well. They can be easily cloned, they don’t need anything server-side, they don’t need any additional tooling on the client side, either. For discovery, you can create a git repo with all the others as submodules, or even multiple repos with different selection of other repos as submodules.

Clone the top one (without recursing into submodules), and you get a list of all available repositories. You can then clone whichever you wish, by updating that particular submodule, or cloning it directly.

Put a README in it, and you’re done.

If you want RSS/Atom feeds, then you will need something a little more dynamic on the server side (or you can pre-generate everything, but then you overcomplicate your local development setup, imo), so something like gitweb, gitlist, or cgit would make sense.

Still, none of those provide the kind of integrations forges do.

If you’re not expecting many contributions, and don’t need or want the convenience of the forges, then a bare git repo or cgit/gitweb/gitlist works fine. I still don’t see the point of something between bare git repos and cgit/etc. If you want something more than cgit/gitweb/gitlist, then there are the existing forges. Gitea/Forgejo works great for small installments, they run fine on a Raspberry Pi. GitLab… I guess GitLab has advantages here and there, too? I found it too heavy for my needs, so never looked deeper into it. The few times I had to interact with it, I used its API.

But circling back to Sheds! You want something that is:

1. Discoverable
2. Doesn’t require a web browser
3. Provides some kind of access to some files, without cloning, for discovery purposes (preferably without a browser)
4. Provides enough information to clone repos
5. Provides enough information to let potential contributors know how to contribute back
6. Provides RSS/ATOM feeds

Did I summarize it well?

How about Gitea/Forgejo, then? Don’t expose the web ui, just the API, and build a minimalist UI on top of it yourself. The API lets people do almost anything (and you can disable the unnecessary parts of it too, simply by not exposing those routes), it provides programmatic discoverability, RSS/ATOM feeds, takes care of cloning too.

Your own UI on top could provide a landing page, the README renders, and whatever else you may wish to expose to browser-users.

Or, you could skip that step, and just expose the web UI. You can disable issues and pull requests, and document in your README how to contribute or report issues.

This way, those who want to use a browser, can, and those who’d prefer an API, can do that too, and those who’d like a combination of the two can do so aswell. Those who’d rather email you rather than use issues or PRs (assuming you have issues / PRs enabled), can still do that. You get to satisfy a lot of people, without inventing anything new and unique without existing tooling or integrations.

How am I expected to have discovered this without a web browser?

I think it’s helpful if you break this question down. In your post, you say:

• Chromium, a web browser, is ~37.7 million lines of expressions
• Linux, the kernel, is ~27 million lines of expressions
• There is no way in hell I could write my own web browser

This is true of a full-featured web browser capable of implementing all the requirements of Github, but that’s not at all required to view https://git.madhouse-project.org/algernon/. I’ve tried loading this URL in netsurf and eww, two browsers written with non-megacorp-scale resources, and they look fine!

Hell, you could even find the data you need using curl in a pinch.

The problem isn’t “web sites”; the problem is JS applications.

ah, certainly

Yeah, I’ve found the same, but I think it’s a system setup issue more than anything. Would it be simpler if you clicked “git://…” and your file explorer opened (so it downloaded in the background and loaded up)?

I’d prefer not to. Cloning a repo is potentially far more resource intensive than viewing a file or two. I don’t want to clone an entire repo to look at its README (or LICENSE, or COPYING, or whatever), or its language-specific pacakage manager file to see if it pulls in crazy dependencies I’d rather not deal with.

Sometimes I just want to look at the file list alone, and decide which one I want to have a quick look at, without having a local copy of the entire thing.

Not to mention that at some point, that local download better be garbage collected. Or auto-updated: if I look at it a week later, I don’t want to see an obsolete version. But then what happens if the repo got force pushed? What happens if I want to look at the same file in different branches? Does it clone it twice? Does it clone it once, but checks out a different branch? What if I want both open? What if the repository is huge? Do I seriously need to wait for a ~500mb repository to clone just to view its README?

It’s not as simple as “clone, display, done!”, I’m afraid. Not unless you have infinite diskspace, bandwidth, and time. I don’t have either.

That’s… a pretty good idea. I like it.