Skip to content

Developer Docs

A practical guide to using ArmGit: creating repositories, working with Git, reviewing and shipping code, and collaborating with others. Some features may be switched off by the ArmGit team, so you may not see every tab described here.

Getting started

  1. Open Register, choose a user name and password, and create your account.
  2. If the site asks you to verify your e-mail address, open the link we send you.
  3. Sign in. Your dashboard shows your repositories and recent activity.

Create or import a repository

  • New repository: choose New repository, give it a name, and pick Public (anyone can read it) or Private (only you and the people you invite).
  • Import from GitHub: on the same page, paste the address of an existing repository to copy it here with its history. For a private repository you will be asked for a GitHub access token. The import runs in the background and shows its progress.

Connect from your computer

Every repository page has a Code button that shows the exact address to copy. You can use either way below.

Over HTTPS

git clone https://armgit.com/<user>/<repository>.git

When Git asks for a password, use an access token (create one under Settings → Access tokens). Tokens are safer than your account password and can be removed at any time. Public repositories can be cloned without signing in.

Over SSH

  1. Create a key on your computer if you do not have one: ssh-keygen -t ed25519
  2. Open Settings → SSH keys, choose to add a key, and paste the contents of your public key file (the one ending in .pub).
  3. Copy the SSH address from the repository's Code button and clone with it.

First push

git init
git add .
git commit -m "First commit"
git branch -M main
git remote add origin <address from the Code button>
git push -u origin main

Large files (Git LFS)

Big binary files such as design files, videos or datasets can be stored with Git LFS.

git lfs install
git lfs track "*.psd"
git add .gitattributes
git commit -m "Track PSD files with LFS"
git push

The site may limit the size of a single file and the total per repository.

Browsing code

  • Branches and tags: use the switcher above the file list to look at another branch, tag or commit.
  • Go to file: press t on a repository page to search for a file by name.
  • File viewer: files are shown with syntax highlighting; you can open the raw file or see who last changed each line.
  • Commits: the commit list and each commit's changes are one click away. Open a commit to see its diff.
  • Search: search inside a repository's code, or search the whole site for users and repositories (typos are tolerated).
  • Search across branches and history: in a repository's code search, pick several branches or tags (for example branches:release/*), search every branch and tag, search past revisions, switch on exhaustive mode when completeness matters, or use a regular expression. Each hit can show the pull request and issues behind the file's latest changes.
  • README: a README.md in the repository's root is shown on the repository home page.
  • Download: download any branch or tag as a ZIP file.

Working together

Issues

Use Issues to report bugs, ask for features and track tasks. An issue has a title, a description (Markdown is supported), labels, an assignee and comments. Close an issue when it is done.

Pull requests

  1. Push your changes to a new branch (or fork the repository if you cannot write to it).
  2. Open Pull requests → New pull request, choose the source and target branch, and describe your change.
  3. Reviewers can comment on the changes. When everyone is happy, a person with write access merges it. The page tells you if there are conflicts to fix first.

Reviews that keep their context. Reviewers can approve or request changes and you can ask specific people to review. After you push more commits, a reviewer sees what changed since their last review, comments on lines that changed afterwards are marked outdated, and reviews given on an older version are marked as such. As the author you can add a reading order (which files to read first, with a note each) to guide reviewers.

Merge blockers, in words. Before you click Merge the page lists everything that still blocks it: required approvals, code-owner review, required builds, a draft state, conflicts or a branch rule.

Draft pull requests and auto-merge. Open a pull request as a draft while it is not ready. When it is ready you can switch on auto-merge: ArmGit merges it for you as soon as the rules are satisfied, and stops by itself if the pull request becomes a draft, is closed or the branch disappears.

Branch protection and code owners. Repository admins protect branches (patterns such as release/*) with required approvals and required builds, and refuse direct pushes. A CODEOWNERS file on the target branch (one pattern per line followed by @user names, the last matching line wins) asks the named people to review changes to those files, and can be made mandatory. Writing Closes #12 in a pull request or commit closes that issue when the change lands.

Contribution rules (for maintainers). In a repository's settings you can ask contributors to link an issue (optionally one carrying an "approved" label), write a description of a minimum length, include tests with code changes, or limit how many pull requests a new contributor may have open. First-time and automated contributors can be held until a maintainer approves them. A pull request that breaks a rule is quarantined: hidden from the public lists, with the reasons shown to its author, who can ask for reconsideration. Maintainers see the held pull requests in one queue and can approve or reject many at once. Rules look at observable facts (size, tests, linked issues, duplicates), not at who or what wrote the change.

Forks and stars

Fork makes your own copy of a repository so you can experiment and then propose changes back with a pull request. Star a repository to bookmark it and show appreciation.

Your action inbox

Open Inbox to see what needs you, grouped by what to do next: needs my review, waiting for me, blocked, ready to merge and done. Each item says in one sentence why it is there ("Your approval is the remaining requirement"). Items disappear as soon as the need is gone. Filter by text, and snooze an item until later.

Builds (CI)

Put a workflow file in .armgit/workflows/ (YAML with jobs, each with an image and steps; triggers: push, pull request, manual). Turn builds on in the repository settings (the ArmGit team must have enabled them for the site); the page shows an estimate of the monthly minutes before you do. Builds run in isolated containers with time, memory and network limits. Pull requests from forks wait for approval unless you choose otherwise.

When a build fails, its page answers three questions:

  1. What failed? The failure is labelled code (a step exited with an error), infrastructure (the build system had a problem; re-running may help), permissions (it was not allowed to run) or limits (a time, memory or monthly allowance stopped it).
  2. What changed since the last successful build? Commits, changed files, dependency and Dockerfile changes, image changes and environment-variable changes.
  3. How can I reproduce it? Copy the shown commands: they check out the same commit and run the job in the same image with the same variables and steps.

Usage: Settings → Usage shows the build minutes used this month per repository, per workflow and per trigger. If a build is refused because an allowance is used up, the message names the limit, who set it and when it resets.

Organizations and teams

Choose New organization. The creator becomes an owner. Owners add people by user name, make others owners, create teams and give a team Read, Write or Admin access to chosen repositories. The organization's base permission (None, Read, Write or Admin) applies to every member in every repository of the organization; teams and individual collaborators can add more, and the highest access wins. Members may be allowed to create repositories. Create a repository in an organization by picking it as the Owner on the new-repository page. Organization owners are owners of its repositories. An organization cannot be deleted while it owns repositories.

Stacked pull requests

To split a big change, branch feature-b from feature-a, open pull request A (feature-a → main) and pull request B (feature-b → feature-a). The pull request page shows the stack, lets you check the whole stack for conflicts, and keeps B from being merged before A. Merge from the bottom up: when A is merged, B is retargeted to main and, if A was squashed or rebased, rebased onto the new tip for you. If that rebase conflicts you are notified and must rebase by hand.

Wiki over git

A wiki is also a git repository: https://armgit.com/<user>/<repository>.wiki.git (or over SSH). Clone it, edit Markdown pages and push to main. Only Markdown pages in the top folder are accepted (the same pages the web editor shows); other files, folders and branches are refused.

Dependency alerts

When enabled by the ArmGit team, the repository's Security tab lists known-vulnerable versions found in package-lock.json, yarn.lock, requirements.txt, poetry.lock, go.mod, Cargo.lock, composer.lock and Gemfile.lock on the default branch, with the severity and the fixed version. You are notified of new alerts; an alert disappears when the vulnerable version is no longer pinned, and you can dismiss one with a reason.

Pages (static sites)

Under Settings → Pages choose a branch (for example gh-pages) and a folder (/ or /docs) of a public repository. The site is served at https://<owner>.<pages domain>/<repository>/ with index.html as start page and 404.html as error page. It runs on its own domain, so it can never touch your account.

Package registry (npm)

Packages must be scoped to a user or an organization, like @you/tool.

npm config set @you:registry https://armgit.com/api/v1/npm/
npm config set //armgit.com/api/v1/npm/:_authToken YOUR_ACCESS_TOKEN
npm publish --access public      # or without --access for a restricted package

Restricted packages (the npm default) can be read only by you or the members of the organization. A published version can never be overwritten; the Packages page of a user or organization (/packages/<name>) lists them. Create the token under Settings → Access tokens with the repo scope.

Builds: matrices, secrets and reusable actions

  • Matrix: strategy: { matrix: { node: [18, 20] } } runs the job once per combination; use ${{ matrix.node }} in the image, commands and env. The values are also in environment variables such as MATRIX_NODE.
  • Secrets: add them under the repository's build settings (names like DEPLOY_TOKEN; values are write-only). Use them only in env: as ${{ secrets.DEPLOY_TOKEN }}. They are masked in logs and are not given to builds of pull requests from forks.
  • Reusable actions: a step uses: owner/repository@version runs a composite action: a repository with an action.yml that declares runs: using: composite and run steps, with optional inputs (passed with with:). Public repositories, or repositories of the same owner, can be used. The version is pinned to the commit it pointed at when the build started.
  • Workflow syntax is ArmGit's own and close to, but not the same as, other systems' YAML.

Discussions, Projects, Wiki and Releases

  • Discussions are for questions and open conversations that are not tasks. In question-and-answer categories you can mark the best reply as the answer.
  • Projects are boards with columns where you can organise issues, pull requests and notes.
  • Wiki pages (Markdown, with history) are edited in the browser, or cloned and pushed with git, when the repository's wiki is enabled.
  • Releases publish a named version of your project (based on a tag) with notes and downloadable files.

Webhooks

In a repository's settings, Webhooks send a signed HTTP request to your server when code is pushed or issues, comments, pull requests or the wiki change. The signature is in the X-ArmGit-Signature-256 header (sha256= followed by the hex HMAC-SHA256 of the request body, using your secret). Failed deliveries are retried and you can see each delivery and redeliver it. Addresses that point to private networks are refused.

Insights

The Insights tab shows activity over time: commits, contributors and visits to the repository.

Collaborators

Repository owners can invite other people from the repository's Settings so that they can push to a private repository or help maintain a public one.

Your account

  • Profile: add a picture, a short bio, your website and location. Your public repositories, stars and contribution graph appear on your profile page.
  • Notifications: the bell shows what happened on things you follow. Choose which e-mails you want in Settings → Notifications.
  • Appearance: switch between light and dark themes in Settings → Appearance.
  • Access tokens and SSH keys: manage them in Settings, and remove any you no longer use. A token can be limited to chosen repositories, which makes it a safe identity for one script or service.
  • Interface and AI: Settings → Interface lets you hide the tabs you do not use (Discussions, Projects, Insights) and switch AI features off for yourself. ArmGit currently has no AI features and sends none of your data to an AI service.

Security

  • Malware scanning: pushes and imports are scanned. A repository that contains malware is quarantined and its owner is told.
  • Secret scanning: pushing a recognised key or token is flagged so that it can be revoked. Dependency alerts flag vulnerable pinned packages when enabled. Add a SECURITY.md and accept private vulnerability reports under the repository's Security tab.
  • Two-factor sign-in, a list of your signed-in devices and alerts for unfamiliar sign-ins are in Settings → Security.

Troubleshooting

Problem What to try
Authentication failed over HTTPS Use your user name and an access token as the password, not your account password.
Permission denied (publickey) over SSH Check that the public key is added in Settings → SSH keys and that you use the SSH address from the Code button.
Repository not found Check the spelling. Private repositories look "not found" to people who do not have access.
Push rejected (non-fast-forward) Someone pushed first. Run git pull --rebase, then push again.
A pull request is "held" or "quarantined" The project uses contribution rules; read the reasons on the pull request and fix them or ask for reconsideration.
A build was not started Open the build or Settings → Usage; the message names the limit (for example the monthly allowance) and when it resets.
A large file is refused Track it with Git LFS (see above) or ask the ArmGit team about the size limit.

Need more help?

Read the FAQ, or use the Contact page to reach the ArmGit team.

Last updated November 15, 2026