Most developers are used to a simple assumption: if you want to participate in open source, you need an account on a platform like GitHub.
But what if you just want to explore a repository, read its code, report a bug, or submit a small fix without tying every action to your personal profile?
That question is one of the reasons I built gitGost.
Try it: https://gitgost.livrasand.com/
Source code: https://github.com/livrasand/gitGost
The problem with identity by default
Open source is built around public collaboration. That openness is valuable, but it can also create a permanent record of personal activity.
A public contribution can expose more than the code itself. Depending on how you contribute, your profile, commit author information, email address, timestamps, and activity history may become searchable and connected to your identity.
For many developers, this isn't a problem.
For others, it can be an unnecessary risk.
Maybe you want to fix a typo without adding another permanent entry to your contribution history. Maybe you want to participate in a controversial project without linking it to your professional profile. Or perhaps you simply prefer to share your work without sharing more personal information than necessary.
I don't think contributing to open source should always require that trade-off.
Privacy shouldn't be a prerequisite you have to sacrifice to participate in open source.
What is gitGost?
gitGost is an open-source, privacy-focused gateway for browsing and contributing to Git repositories.
It lets you explore repositories without creating an account on the platform you're browsing. It also provides a way to submit contributions without directly attaching your personal platform identity to them.
The project currently supports GitHub, GitLab, and Codeberg, with additional Git platforms planned.
You can browse repository files, branches, commits, releases, tags, issues, pull requests, wikis, and other project information through its web interface.
No account is required just to explore.
The goal isn't to replace GitHub or other Git platforms. It's to offer another way to access and participate in the open-source ecosystem.
Browsing without an account
Sometimes you don't need a social profile, a contribution graph, or another account.
You just need the code.
With gitGost, you can explore repositories and discover projects without signing in. That makes it useful for reading source code, checking a project's activity, reviewing releases, and learning from other developers' work.
It also reduces the need to expose your browsing activity to a platform through a personal account.
This is a simple idea, but I think it's worth building tools around: accessing public code shouldn't always require establishing a personal identity first.
Contributing anonymously with Git
I also wanted gitGost to work with the tools developers already use.
You don't need a special Git client or a browser extension to submit a code contribution. You can use Git from your terminal and add gitGost as another remote.
For example, suppose you want to contribute a documentation fix to a public repository.
First, add the gitGost remote:
git remote add gost https://gitgost.livrasand.com/v1/gh/username/repo
Create a branch and make your changes as usual:
git checkout -b fix-documentation
git commit -am "fix: correct a typo in the documentation"
Then push your branch through gitGost:
git push gost fix-documentation:main
The gateway processes the contribution and, for supported workflows, opens a pull request through its anonymous contribution identity.
The exact behavior depends on the target platform and the configured workflow, but the idea is straightforward: you can use your existing Git workflow without directly linking the contribution to your personal platform account.
No need to replace Git. No need to learn a new version control system.
Just another remote.
What about commit metadata?
Git commits can contain author names, email addresses, and timestamps. That information can remain in repository history long after the original contribution was made.
gitGost is designed to minimize this exposure by stripping identifying authorship metadata from supported contribution workflows and using a neutral identity for pull requests.
This helps reduce direct links between a contribution and a personal profile.
However, metadata is only one part of the problem.
Your code can reveal information through distinctive coding patterns. Commit messages may contain recognizable phrases. The timing of a contribution can be correlated with activity elsewhere. Files you upload may contain EXIF or other embedded metadata.
An anonymous contribution is not automatically an unidentifiable contribution.
That's why I prefer to describe gitGost as a privacy tool with explicit limitations, rather than promise perfect anonymity.
An important limitation: your IP address
There is something users should understand before using gitGost.
The destination platform does not automatically see your original IP address, but the gitGost server can.
When you connect directly to the public gitGost instance, the server receives your network connection. Routing a contribution through a gateway changes which IP address the destination platform sees; it does not, by itself, hide your IP from the gateway operator.
If you need stronger network-level privacy, consider routing your connection through Tor or another trusted privacy network. That still doesn't eliminate every possible identification risk.
You should also consider code style, timing correlation, commit content, and metadata embedded in files.
For a detailed explanation of the project's assumptions and limitations, see the gitGost threat model.
I believe privacy tools should explain what they protect against, what they don't protect against, and which parties still need to be trusted.
Anything less would be misleading.
Privacy and accountability can coexist
Anonymous contributions can be abused. That's a real concern, and ignoring it would make the project less useful for everyone.
gitGost is intended for legitimate, good-faith contributions, not harassment, spam, malicious code, or evading bans and moderation.
The project includes rate limits, repository and commit size restrictions, validation, and other safeguards to reduce abuse. Contributions still go through the destination project's review process, and maintainers retain control over whether they accept changes.
Repository maintainers can also opt out of anonymous contributions through a .gitgost.yml configuration file:
DENY_ALL: true
Privacy doesn't mean that maintainers lose control of their projects.
It means contributors can have another option when personal attribution isn't necessary.
Why make it open source?
A privacy tool asks users to trust the software handling their requests. That makes transparency especially important.
gitGost is licensed under AGPL-3.0. You can inspect the implementation, report problems, contribute improvements, or run your own instance.
Self-hosting gives you more control over the infrastructure you trust, although it also means you're responsible for operating and securing it.
I don't want privacy to be a promise that users have to accept on faith. I'd rather make the implementation available for people to examine.
Who is gitGost for?
I built gitGost for developers who want more control over how their public contributions are associated with their identities.
That might mean someone who wants to avoid unnecessary email exposure, a developer who doesn't want every small fix attached to a professional profile, or someone contributing to a project where public attribution could create personal or professional complications.
It can also be useful for people who simply want to browse public repositories without creating yet another account.
You don't need a dramatic reason to care about privacy.
Sometimes, not wanting to publish more personal information than necessary is reason enough.
Try it, inspect it, or contribute
gitGost is an ongoing open-source project, and there is still plenty of work to do.
If you're interested in privacy, Git infrastructure, or making open source more accessible, I'd appreciate your feedback and contributions.
- Explore the web interface: https://gitgost.livrasand.com/
- Read the source code: https://github.com/livrasand/gitGost
- Review the threat model: https://github.com/livrasand/gitGost/blob/main/THREAT_MODEL.md
- Read the license: https://github.com/livrasand/gitGost/blob/main/LICENSE
I'm not trying to remove identity from every part of software development. There are many situations where attribution is useful and deserved.
I just believe developers should have a choice.
Open source can be public without requiring every participant to expose their personal identity in the same way.
Browse freely. Contribute responsibly. Be a gost. 👻
Cover photo by: unsplash.com · A person is coding on a laptop at night. photo – Free Image on Unsplash
Top comments (0)