Documentation

Getting started

Download the installer from the home page and run it. Memento installs for the current user, needs no administrator rights, and keeps itself up to date. The portable build is the same application in a single file, if you would rather not install anything.

Git itself is not bundled. Memento drives the git already on your machine, so your credentials, SSH keys, hooks and configuration keep working exactly as they do in a terminal. If git --version answers in a terminal, Memento will work.

Opening a repository

The first screen offers three ways in:

• Open a folder — any folder containing a .git. If it is not a repository yet, Memento offers to create one.
• Clone a URL — https://, git@… or ssh://. The folder name is filled in from the URL, and the parent folder is remembered for next time.
• Sign in to GitHub — then pick from your repositories, private ones included, without typing a URL.

Open repositories become tabs. Ctrl K switches between them, and the Projects view lists every repository Memento knows with its branch, its uncommitted changes and how far ahead or behind it is.

The history

The commit graph draws lanes for every branch, with merges, refs and tags. Only the rows on screen exist in the page, so it stays smooth on repositories with tens of thousands of commits.

Ctrl F filters it. Message, author, file or date — the filtering is done by git itself rather than in the app, so it is instant on a large history. Search terms are passed as fixed strings, so a term that begins with a dash is a search term and not an option.

Selecting a commit shows its author, its full message, the files it touched and the diff for each. From there you can blame a file at that revision, or browse the entire tree as it stood at that commit.

Changes and committing

The Changes view lists what is staged, what is not, and what git does not track yet. You can stage a whole file, a single hunk, or individual lines — useful when one file holds two unrelated changes and only one of them belongs in this commit.

Line-by-line staging works by building a patch and feeding it to git apply --cached, which means it respects everything git already knows: end-of-line settings, filters, and files with no trailing newline.

Writing the commit

• Summary and description are separate fields, so the first line stays short.
• Ctrl ↵ commits.
• Recent messages offers the last few subjects, for when a change follows on from the previous one.
• Amend rewrites the last commit. Memento will not amend a commit that has already been pushed without saying so.

Images are diffed side by side — before and after — for png, jpg, gif, webp and friends.

Branches

The sidebar lists local branches, remote branches grouped by remote, tags and stashes. Double-click a branch to check it out; right-click for everything else: merge, rebase, rename, delete, copy the name, or set an automation rule.

Stashes

Stashes are listed with the branch they were taken from, so a stash from three weeks ago is still identifiable. Apply, pop or drop from the same list, and see the diff before deciding.

Ghost branches

When a branch's remote disappears — usually because its pull request was merged and the branch deleted — Memento tells you once, and offers to look at it. It never deletes a local branch for you: it may hold work that exists nowhere else.

A light git-flow

If you turn it on, Start a branch creates feature/…, fix/… or hotfix/… from the right base, and the finish step merges back into the right target. The rules live in the repository, so a teammate running Memento follows the same ones.

Conflicts

When a merge, rebase, cherry-pick or revert conflicts, a banner appears and the Conflicts view opens. Files in conflict are listed on the left; the file itself is on the right, cut into blocks.

Common text stays readable. Each conflicting block is shown as two panes — ours and theirs — with four choices: keep ours, keep theirs, keep both, or keep both the other way round. Once a block is decided it folds down to the result you picked.

• All ours / All theirs decide every block at once.
• Keep our file / Keep their file take a whole file without reading it — the only option for a binary.
• Mark resolved becomes available once every block is decided. The file is staged for you.
• Abort undoes the whole operation.

Line endings are preserved exactly: CRLF stays CRLF, and a file with no trailing newline keeps none. The diff3 style, which also shows the common ancestor, is understood.

Automation

This is the part of Memento that is actually different, so it is worth reading properly. Repository → Automation settings shows the whole cycle, in order, with what each step does. Nothing runs that is not on that list.

The cycle runs every minute by default — 30 seconds to 15 minutes, your choice — and keeps running when the window is minimised, which is the point. The panel shows when the last cycle ran and whether it finished.

Auto-pull

Fetches, then pulls the current branch with --ff-only. It moves your branch forward when there is nothing to decide, and refuses the moment a decision would be needed.

If your branch has diverged — commits on both sides — it stops and says so, with how many commits each way, and offers to merge the remote. It will not merge or rebase behind your back.

Auto-merge

Pick a source branch and a target in the per-branch table. Whenever the source can merge into the target without conflict, it does.

• You do not have to be on the target. Merging into a branch you are not on happens in a throwaway worktree, so your working copy, your open files and your uncommitted changes are never touched.
• It leaves a trace. Merges use --no-ff, so there is always a commit recording when the branch landed, instead of a pointer that quietly moved and left no evidence.
• A conflict aborts everything. The merge is undone immediately — nothing half-done, nothing to clean up — then a banner stays until you deal with it, with a button that replays the merge so the conflict resolver opens on it.
• If the target branch is already checked out in another worktree, the merge is skipped rather than forced.

Auto-commit

Saves work in progress once nothing has changed for a while — one minute to one hour, your choice. Commits are labelled WIP … (Memento auto-commit) so they are easy to spot, amend or squash later.

If a pre-commit hook refuses, no commit is forced, the files Memento staged are put back as they were, and the hook's own message is shown once.

Auto-push

Pushes only what cannot be rejected:

• Never when the branch is behind or diverged — auto-pull deals with that first.
• Never with --force, in any form.
• Branches with no remote yet are published only if you ask for it.
• If the remote rejects the push anyway, nothing is overwritten and git's own message is shown.

Both auto-commit and auto-push take a list of branch patterns — main, feature/* — and an empty list means every branch.

In the background

Closing the window does not quit Memento. It folds into the notification area and keeps running its cycle, so a repository stays watched while you work on something else. Click the icon to bring the window back; right-click it to pause the cycle, open these settings, install a waiting update, or quit for good. Quitting from that menu is the only thing that really stops Memento.

A hidden window is not drawn at all, which is where the saving comes from — the cycle itself keeps its usual pace, because a paused cycle would defeat the purpose. If you would rather closing the window meant quitting, turn off Keep Memento running in the notification area in Automation settings → In the background.

The same panel can start Memento with your Windows session, already folded away, so a repository is watched from the moment you sign in. Installed builds only: the portable one has no fixed place on disk to point the shortcut at.

What automation cannot do

Two branches can merge with no textual conflict at all and still produce code that does not work: one side renames a function, the other adds a call to the old name. Git sees no conflict, because there is none in the text. Memento cannot see it either.

The same honesty applies to auto-push: once something is pushed it is on the remote, and possibly in other people's clones. Undoing that means a force-push, which Memento will never do on its own.

Working as a team

Shared task lists usually mean an account somewhere. Memento keeps them in the repository itself, in a ref of its own — refs/memento/data, outside refs/heads.

That placement is the whole design:

• The same list on every branch. A file in the working tree follows the branch you are on: the list would change at every checkout.
• Never in a diff. It is not in the working tree, so it never appears in your changes, and never in the history graph either.
• Never a conflict. It is not on a branch, so no merge can conflict with it.
• Still shared. Fetch and push carry the ref along, so teammates see the same board through git alone.

Concurrent edits

Entries merge by id, most recently modified wins. Two people ticking different items keep both. Deletions leave a tombstone for sixty days, so a teammate who still had the item cannot bring it back on their next sync.

Presence

Each client records which branch it is on, and the sidebar shows teammates' initials against that branch — outlined green while they are actually there, plain once they have been idle half an hour. It is written on a branch change or every ten minutes, never more.

GitHub

Signing in uses GitHub's device flow: a code to type in your browser, no password ever seen by the app. The token is encrypted with your operating system's own key store and never leaves the main process — the interface never touches it.

The GitHub view shows, for the repository you have open:

• The pull request for your current branch — or a one-line form to open it, with the default base filled in.
• Check runs for the head commit, pass or fail per job, clickable through to the run.
• Other open pull requests with their requested reviewers.
• Issues assigned to you.

A green pull request can be merged from there.

Requests are cached for 25 seconds, which keeps the automatic cycle far inside GitHub's rate limit. A repository that is not on GitHub, a missing token or no network give an empty view — never an error.

Notifications

Everything Memento has to say goes into a journal behind the bell in the title bar: the whole session, with an unread count and the severity down the left edge. A desktop notification is raised on top of that only for what needs a person, and only when Memento does not have the focus.

Twelve kinds of event, each set to off, in app, or in app and on your desktop in Settings → Alerts:

The Android app

A phone has no local repository, so the mobile app follows what GitHub knows: your repositories with their recent commits, open pull requests with their reviewers, check runs per job, the issues assigned to you, and the team todo list — the same one the desktop keeps in the repository, which you can tick off from the phone.

How notifications reach you

There is no push server. The phone asks GitHub itself: every five minutes while the app is open, every time you come back to it, and about every fifteen minutes in the background with the app closed. Nothing about your work passes through anyone else, and there is nothing to host.

Fifteen minutes is the floor Android allows for background work, and it stretches further on a low battery. That is the trade: a few minutes of latency in exchange for no third party.

Pushes and branches

GitHub's notification feed never mentions a push — it only covers threads you are subscribed to. To tell you that someone pushed to a branch, Memento reads each watched repository's activity instead. That is one request per repository, which is why the repository list in Settings matters: pick the ones you care about, and only those are checked.

Keyboard

Updates

Memento checks this site on startup and every four hours, downloads quietly in the background, and asks before restarting. There is no store and no account in the way. Settings → App shows the installed version and checks on demand.

The Android app does the same, reading a small manifest from this site. It never installs silently — that would need permissions this app has no business holding — so it offers the download and Android takes over.

Privacy

• No account. Memento works fully before you sign in to anything. GitHub sign-in is optional and only adds GitHub features.
• No telemetry. Nothing is measured, nothing is sent. There is no analytics code in either app.
• Your code stays put. Git runs on your machine against your repositories, as it always did.
• The GitHub token is encrypted with your operating system's key store — DPAPI on Windows — and never leaves the main process.
• Team data travels inside your own repository, to your own remote. There is no Memento server, because there is no Memento server to have.

Troubleshooting

Automatic actions are not happening

Open Repository → Automation settings. The panel says when the last cycle ran and whether it finished; "could not finish" almost always means no network. Check that the rule you expect is switched on, and that the branch matches the patterns you set.

Auto-merge does nothing

Check the target in the per-branch table — a source with no target is off. If the target is the branch you are currently on, a dirty working copy postpones the merge; off-branch merges are not affected. And if the source has nothing new, there is nothing to do.

Auto-commit never fires

It waits for a period with no changes at all, so it will not interrupt you mid-edit. It also ignores files git does not track unless you asked for them. If a pre-commit hook is refusing, the reason appears in the notification centre.

A push was rejected

Someone pushed to the same branch first. Nothing was overwritten. Pull — auto-pull will do it on the next cycle if it fast-forwards — then push again.

Sign-in to GitHub fails

The device flow needs to reach github.com. A VPN that is connected but not actually routing traffic looks exactly like being online and will fail here; the app says so explicitly rather than doing nothing.

Something went wrong and I want the old state

Repository → Reflog. Every move of HEAD is listed, and anything Memento did automatically is a normal commit or ref move like any other — nothing is special-cased or hidden from git.