Skip to main content
Isabel’s Dotfiles is mirrored across multiple Git hosting platforms to ensure availability and provide alternative access methods. The primary development repository is on GitHub, with automatic synchronization to other platforms.

​
Official mirrors

The configuration is available at the following locations:

GitHub

Primary repositoryMain development location. All pull requests, issues, and discussions happen here.

GitLab

MirrorSynchronized mirror with the same commit history.

Codeberg

MirrorCommunity-focused Git hosting mirror.

Iztea

Self-hosted mirrorIsabel’s personal Git instance.

Tangled

Tangled mirrorAlternative self-hosted mirror.

​
Cloning from mirrors

You can clone the repository from any of the mirrors: 
git clone https://github.com/isabelroses/dotfiles.git
All mirrors contain identical commit history. You can safely switch between them as remotes.

​
Using Nix flakes with mirrors

When referencing the dotfiles flake, you can use any of the mirrors: 
{
  inputs.isabel-dotfiles.url = "github:isabelroses/dotfiles";
}
The GitHub mirror is recommended for Nix flakes as it benefits from GitHub’s CDN and reliability.

​
Mirror synchronization

Mirrors are synchronized using the push-mirrors just command, which pushes changes to all configured mirrors: 
just push-mirrors
This command pushes to:
  • GitLab: Regular push to main branch
  • Codeberg: Mirror push (all refs)
  • Tangled: Mirror push (all refs)
Mirror synchronization is typically performed by the repository maintainer after merging changes to the main branch.

​
Switching remotes

If you’ve cloned from one mirror and want to switch to another:
1

Check current remote

git remote -v
2

Change the remote URL

# Switch to GitLab
git remote set-url origin https://gitlab.com/isabelroses/dotfiles.git

# Or switch to Codeberg
git remote set-url origin https://codeberg.org/isabel/dotfiles.git
3

Verify the change

git remote -v
4

Fetch from new remote

git fetch origin

​
Adding multiple remotes

You can configure multiple remotes to pull from different mirrors: 
# Add GitLab as a secondary remote
git remote add gitlab https://gitlab.com/isabelroses/dotfiles.git

# Add Codeberg
git remote add codeberg https://codeberg.org/isabel/dotfiles.git

# Fetch from all remotes
git fetch --all
This allows you to:
  • Compare commits across mirrors
  • Pull from a different mirror if one is unavailable
  • Verify mirror synchronization

​
Mirror status

All mirrors should contain identical commits. To verify synchronization: 
# Check commit hash on main branch
git ls-remote https://github.com/isabelroses/dotfiles.git main
git ls-remote https://gitlab.com/isabelroses/dotfiles.git main
git ls-remote https://codeberg.org/isabel/dotfiles.git main
If the commit hashes match, the mirrors are synchronized.

​
Contributing

Pull requests and issues should only be submitted to the GitHub repository. Other mirrors are read-only and do not accept contributions.
To contribute:
  1. Fork the GitHub repository
  2. Create a feature branch
  3. Make your changes
  4. Submit a pull request to the GitHub repository
See the Contributing guide for more details.

​
Mirror implementation

The mirror push is implemented in the justfile at justfile:136-142: 
# push to the mirrors
[group('dev')]
[no-exit-message]
push-mirrors:
    git push [email protected]:isabelroses/dotfiles.git
    git push --mirror ssh://[email protected]/isabel/dotfiles.git
    git push --mirror [email protected]:isabelroses.com/dotfiles
  • GitLab: Uses a standard git push which only pushes the current branch
  • Codeberg: Uses git push --mirror which pushes all refs (branches, tags)
  • Tangled: Uses git push --mirror for complete synchronization
The mirror push ensures that all branches, tags, and commits are replicated across platforms.

​
Frequently asked questions

Multiple mirrors provide:
  • Redundancy: If one platform experiences downtime, others remain available
  • Choice: Users can choose their preferred Git hosting platform
  • Privacy: Self-hosted mirrors offer alternatives to large platforms
  • Censorship resistance: Distributed hosting makes the repository harder to take down
For most users, the GitHub mirror is recommended because:
  • It’s the primary development location
  • Pull requests and issues are handled there
  • GitHub’s infrastructure is highly reliable
  • Better integration with Nix flake tooling
However, if you prefer community-run or self-hosted infrastructure, any mirror works equally well for read-only operations.
Mirrors are synchronized whenever changes are pushed to the main repository, typically:
  • After merging pull requests
  • After direct commits to main
  • When running just push-mirrors
There is no automated scheduled synchronization. Mirrors are updated manually or as part of the development workflow.
No. Only the GitHub repository accepts issues and pull requests. Mirrors are maintained for distribution and redundancy, not for collaborative development.If you want to contribute, fork the GitHub repository and submit your pull request there.
If you notice a mirror is behind the main repository:
  1. Check the commit hash on both repositories
  2. Wait a few hours in case synchronization is in progress
  3. If still out of sync after 24 hours, open an issue on the GitHub repository
Typically, mirrors are synchronized within minutes of changes being pushed to GitHub.

​
Technical details

The mirrors use SSH authentication for pushing. The push-mirrors command requires appropriate SSH keys configured for each platform.

​
SSH configuration

To run just push-mirrors yourself, you need SSH keys set up for:
~/.ssh/config
Host gitlab.com
  HostName gitlab.com
  User git
  IdentityFile ~/.ssh/id_ed25519

Host codeberg.org
  HostName codeberg.org
  User git
  IdentityFile ~/.ssh/id_ed25519

Host tangled.org
  HostName tangled.org
  User git
  IdentityFile ~/.ssh/id_ed25519

​
Automation

While there’s no automated CI/CD for mirror synchronization, you could set up GitHub Actions to automatically push to mirrors:
.github/workflows/mirror.yml
name: Mirror to platforms
on:
  push:
    branches: [main]
jobs:
  mirror:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Push to mirrors
        run: |
          git push https://${{ secrets.GITLAB_TOKEN }}@gitlab.com/isabelroses/dotfiles.git
          git push --mirror https://${{ secrets.CODEBERG_TOKEN }}@codeberg.org/isabel/dotfiles.git
The above is an example. The actual repository may or may not use automated mirroring.

Build docs developers (and LLMs) love

Get started for freeTalk to us