[chrisseaton]

You can still work with your colleagues by pushing and pulling your own repos without involving GitHub.

I think centralised CI is the real problem. I don't have the compute power in my home to run our full test suite, so I can't push with confidence without my CI cluster.

[TAForObvReasons]

Issues and other GH infrastructure is arguably a bigger problem. That metadata is locked within the Github silo with no easy way to export it elsewhere.

[dom96]

This is indeed the crux of the problem. I've been thinking about this a lot (and I wouldn't be surprised if it exists already), we need a decentralised method of storing issues and other things inside our git repos.

[musicmatze]

https://github.com/neithernut/git-dit provides a distributed issue tracker inside git, without cluttering the repository with unneeded files and also gives the possibility for having tree-like conversation, referencing issues and so on.

Unfortunately, no non-cli frontend exists right now (feel free to build one, shouldn't be complicated). Also some convenience is still missing, but could easily be integrated.

What's also missing is a way to give users of the tool access to a repository where they can submit issues (which then could also be used by a web/gui frontend for the tool). This is not the domain of git-dit itself, but a solution needs to be found. One idea would be a publish repo (where everyone can push) which automatically does some sanity-verification on the issues and forwards them to the maintainers repository... or something like that.

Also, https://github.com/vitiral/artifact/ is a really nice tool to do planning of an application or library inside a git repository. I am currently starting using it in iamg (https://imag-pim.org) and it is really wonderful. The author currently does a reimplementation of its core functionality to make it even more powerful.

[zeveb]

If you think about it, there's no particular reasons why the metadata can't live in (and be tracked by) the repo itself.

Issues could live in /issues. Simple command-line (or GUI) tools could edit them. I'm thinking in particular of how password-store[0] makes tracking history in a git repo invisible: it Just Works™.

Discussions could live in /discussions, stored in something like RFC822 format. Again, simple CLI (or GUI, if you swing that way) tools could manipulate this easily.

A wiki can, again, live in the same repo.

PRs are a little different, since they really do need to live outside the repo. But what is a PR other than someone saying, 'hey, please pull my branch into yours'?

[0] https://www.passwordstore.org/

[Klathmon]

PRs and other things could also just live in a "shadow repo". Even if just by convention.

You have a `Product` repo and a `Product-meta` repo.

The biggest issue I have with using git as a truly decentralized system is remote management. Unless you want to be manually futzing with remotes on every single client and pushing/fetching from others correctly, you need some kind of central server.

I really think there is a hole here for a product that works with git underneath, but gives a nice easy way to manage all that complexity.

[hossbeast]

Like GitHub?

[Klathmon]

I missed a word there, I meant a "decentralized way of managing all that complexity"!

[leejo]

I know of at least one solution: https://bifax.org/

[Procrastes]

Great link, thanks! I've been looking for something like this.

[jcelerier]

it's an issue for issues, but wikis at least are also git repos : https://help.github.com/articles/adding-and-editing-wiki-pag...

[notheguyouthink]

Also, the workflow on Github is one many people like, and it differs a bit if you have to use git "the old fashioned way". Not that it's hard or impossible, but it differs. I can't imagine explaining the GitHub-less workflow to my colleges..

[notheguyouthink]

\*colleague.

[WorldMaker]

There are several attempts at tracking issues inside a repository. What we really need to sell the concept, though, I think is one that can reasonably sync with GitHub Issues. GitHub Issues are a reasonable front end for issue reporting for casual and non-technical users and if you can interoperate with them you don't have to reinvent that basic CMS.

Every now and then I sketch ideas on the subject, but haven't yet gotten someone to pay me to build it. ;)

[drdaeman]

GitLab CI is really sweet, because you deploy your own runners (workers) whereever you want. Downside is, the control is not a standalone CI app but a part of GitLab (or I'm unaware about something).

Drone is very promising but last time I've checked the documentation had some holes in it. The website is "coming soon" and IIRC it's like this for quite a long while.

I'm unaware about any CIs that are usable with local repos. Would be neat to just run a local command and it would spawn a worker somewhere (local or through a remote coordinator) and run the tests on whatever I have in the working tree, just like it happens with centralized repo+CI combos. It's too frequent I find myself doing `git commit -m 'Fix that stupid typo in previous commit'`.

[sytse]

We're working on a 'CI only' mode so you can easily use GitLab CI without the rest of GitLab. This is already possible but now it requires some configuration.

For your local use case GitLab Runner has a local mode exec, although that is currently being reworked https://gitlab.com/gitlab-org/gitlab-runner/issues/2797#note...