# Gitnuro: a Compose and JGit desktop Git client with no account attached

> Gitnuro is a GPL-3.0 Git client built on JetBrains Compose and JGit, distributed as Flatpak, JAR, installer or Homebrew cask. It is fast to set up and honest about its gaps, including unsigned macOS builds and credential setups it cannot handle.

**JetpackDuba/Gitnuro** — A FOSS Git multiplatform client for newbies and pros

- Repository: https://github.com/JetpackDuba/Gitnuro
- Website: https://gitnuro.com/
- Stars: 2,782 · Forks: 160
- Language: Kotlin
- License: GPL-3.0
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/jetpackduba-gitnuro

## What Gitnuro is for, and who it is not for

Gitnuro is a graphical Git client. The README states the goal directly: a multiplatform open source Git client "without any kind of constraint to how you can use it nor relying on web technologies." That second clause is the design thesis. Instead of wrapping a browser engine, the interface is drawn with JetBrains Compose, and the Git work is done by JGit, the Java implementation of Git. The repository topics list compose-multiplatform, jetbrains-compose, jgit, kotlin, multiplatform and rust, and the top-level tree contains app/, common/, data/, domain/ and ui/ modules alongside an rs/ directory for Rust code and a compose-desktop.pro file. So the desktop client is Kotlin and Compose on top of JGit, with a Rust component in the tree.

The audience is stated in the repository description: "A FOSS Git multiplatform client for newbies and pros." The feature list supports that. A beginner gets staging, committing, pulling, pushing and a history log with branches. Someone who already lives on the command line gets interactive rebase, hunk and line-level staging, blame, file history, submodules, force push and detached HEAD checkout. The interface is not a wrapper around git(1); it is JGit underneath, which matters when you hit an operation the JGit implementation handles differently from the reference client.

It is the wrong tool if you want a Git client that is also an account, a code host or a review system. Gitnuro does not track data, per its own FAQ, and it does not try to be a hosting service. It is a local client for repositories you already have a remote for.

## The Compose plus JGit mechanism, and what it means in practice

The architecture visible in the repository is a layered one. The ui/ module holds the Compose screens, data/ and domain/ hold the application's data and business logic, common/ holds shared code, and app/ is the entry point that assembles them. Git operations are delegated to JGit rather than shelling out to the system Git binary, and the rs/ directory indicates that some part of the work is written in Rust, which is unusual for a Compose desktop app and suggests a native component rather than pure JVM code.

That choice has consequences. Because the client does not depend on a system Git installation, it behaves the same on Linux, Windows and macOS as far as the JVM and the Rust component allow. But it also means the set of supported operations is bounded by what the project has implemented on top of JGit. The README's planned-features list is the honest signal here: create and apply patches, remove tags from remote, view stashes in the log tree, syntax highlighting for diff, extra log options, and customisation settings are all listed as not yet done. Interactive rebase, blame and file history are done. If your workflow depends on patch files, that is a gap, not a detail.

Theming is handled through a JSON file with ARGB hex colour values, and the README warns that themes may break with new releases, with the default theme as the fallback. That is a reasonable trade: a documented escape hatch with a documented failure mode.

## Installing Gitnuro and making a first commit

On Linux the documented route is Flatpak, either from Flathub or from the command line. If Flathub is not configured yet, the README gives the command to add the remote first, then the install command. After installation the app appears as com.jetpackduba.Gitnuro.

```bash
flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
flatpak install com.jetpackduba.Gitnuro
```

There is also a portable JAR, which the README says requires JRE 17. On macOS you can install through Homebrew with the tap-style formula name, or download the ZIP containing the app bundle from the releases page.

```bash
brew install jetpackduba/apps/gitnuro
```

Windows users get an installable and portable build from the latest release page. There is no package manager command documented for Windows in the README.

For a first real use, open Gitnuro and either clone an existing repository or start a new local one, both of which are listed features. Then the everyday loop is the same as any client: stage files or individual hunks, write a commit message, commit, and push. The README lists stage and unstage of hunks and of specific lines as separate capabilities, so you can commit part of a file without leaving the GUI. If you want to try a custom theme, the README provides a JSON example with keys such as primary, background, surface, addFile, deletedFile and isLight, and states that colours use ARGB hex format. Note the README's own example contains what looks like an extra F in one value, onPrimary, so copy the structure rather than trusting every character of that sample.

## Authentication is where Gitnuro gets specific about its limits

The README devotes a FAQ entry to authentication failures and names two setups that are known to be problematic: a multicast DNS remote URL, and a self-signed server certificate. For the first, the README points to an issue thread and a workaround comment rather than describing the fix inline. For the second, it links an issue with no workaround stated. That is a real constraint, and it is the kind of thing you should test before moving a team onto the client.

Git Credential Manager (manager-core) is supported, but only if you give the full path to the binary in your .gitconfig. The README gives a Linux example and a Windows example. On Windows it notes you may want to edit C:\Program Files\Git\etc\gitconfig.

```
[credential]
   helper = /usr/share/git-credential-manager-core/git-credential-manager-core
```

If you are used to a Git client that discovers your credential helper automatically, this is a manual step you have to know about. The README does not document rollback behaviour for failed operations, and it does not describe how partial failures during a rebase or a force push are surfaced, so those are questions to answer by reading the issue tracker rather than the documentation.

## Where Gitnuro sits next to Gittyup and RelaGit

The related searches around this project include Gittyup and RelaGit, which are the two other open source desktop Git clients people commonly weigh against it. The meaningful difference is the stack. Gittyup is a C++ client built on libgit2, so it links against a native Git library and ships as a compiled desktop application without a JVM. RelaGit is a React and TypeScript client, which puts it on the web-technology side of the line that Gitnuro's README explicitly draws for itself. Gitnuro sits between them: no browser engine, but a JVM and Compose runtime instead of a C++ toolkit.

That has practical consequences. Gitnuro's JAR distribution means the same artifact runs anywhere a JRE 17 is available, and the Flatpak and Homebrew packages cover the two desktop platforms with package managers. A libgit2 client typically has a smaller memory footprint and no JVM startup cost, which matters if you open and close the client many times a day. A web-technology client usually has a larger ecosystem of UI components and faster iteration on layout, at the cost of the runtime the README was written to avoid. None of these differences is settled by a feature checklist; they show up in startup time, memory and how the diff view feels on a large repository.

## Licence, maintenance and upgrade cost

Gitnuro is GPL-3.0. The README answers the question of cost plainly: free in both meanings, money and freedom. The practical implication of GPL-3.0 for a desktop client is that if you fork it and distribute a modified binary, you take on the licence's source-distribution obligations. Using it to work on your own repositories does not trigger anything. This is not legal advice; read LICENSE in the repository if you plan to redistribute a build.

The repository is not archived, and the last push was on 2026-09-21. The most recent release is 2.0.0-beta03, published the same day, preceded by 2.0.0-beta02 on 2026-08-28 and 2.0.0-beta01 on 2026-08-11. That cadence matters for adoption: the current line is a beta series, so the stable version people install from Flathub or Homebrew may not be the same code as the newest release. Upgrades are cheap on Linux and macOS because the package managers handle them, but the README's warning that custom themes may break with new releases means a themed setup is a recurring maintenance item, not a one-time configuration.

## Conclusion

Gitnuro fits developers who want a desktop Git client that does not route through a web stack, and who work on Linux, Windows or macOS with a standard HTTPS or SSH remote. It is not the right choice if your remote uses a multicast DNS URL or a self-signed certificate, because the README lists both as known authentication problems, and it is not the right choice if you need a signed macOS app today. Before adopting it, verify that JGit can authenticate against your remote, and if you use Git Credential Manager, confirm you can put the full binary path into the credential helper line of your .gitconfig.

## FAQ

### Is Gitnuro completely free?

Yes. The README answers this directly, saying it is free in both meanings of the word: in money and in freedom. The licence is GPL-3.0.

### How do I install Gitnuro on Ubuntu or another Linux distribution?

The README documents Flatpak as the Linux route, installing com.jetpackduba.Gitnuro from Flathub. If Flathub is not configured, add it first with the flatpak remote-add command shown in the README. A portable JAR requiring JRE 17 is also available.

### Does Gitnuro support Git Credential Manager?

Yes, but the README says it requires specifying the full path of the binary in your .gitconfig under the credential helper key. It gives separate examples for Linux and Windows.

### Why does authentication fail in Gitnuro?

The README lists two known problematic setups: a multicast DNS remote URL, for which it links a workaround, and a self-signed server certificate, for which it links an issue without a workaround. It asks users to open a new issue if the cause is something else.

### Why is the macOS version of Gitnuro not signed?

The README says the Apple Developer Program costs too much for a platform that currently has very few users, and that it may pay for signing if it becomes a heavily requested feature.

### Can I create a custom theme for Gitnuro?

Yes. The README says themes are set in a JSON format using ARGB hex colours, and warns that themes may break with new releases, in which case the default theme is used as a fallback.

## Sources

- [JetpackDuba/Gitnuro on GitHub](https://github.com/JetpackDuba/Gitnuro)
- [License: GPL-3.0](https://github.com/JetpackDuba/Gitnuro/blob/main/LICENSE)
- [Project website](https://gitnuro.com/)
- [README](https://github.com/JetpackDuba/Gitnuro/blob/main/README.md)
- [Releases](https://github.com/JetpackDuba/Gitnuro/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jetpackduba-gitnuro