Surprised to see they kept Tauri. In our experience of using Tauri, it has been a significant source of compatibility and performance issues related to it's use of WebKit and WebKitGTK. So much so that we have started an effort of migrating away from it for our app, in favor of Electron (https://github.com/gitbutlerapp/gitbutler/tree/master/apps/l...)
The choice was made specifically for the benefit of our users, but we were also pleasantly surprised by how much better the development experience is with it.
The app has a built-in mechanism for going back in time (an operations log) which can be used for undoing situations that should not arise in the first place. It can be accessed via the app (there's a history tab) as well as via the CLI https://docs.gitbutler.com/commands/but-oplog
NB - the CLI version of GitButler is not yet at feature parity with the graphical version of the app yet
You are right - it is something we did intentionally, but I would like to learn more from your use case - what is the reason to prefer isolation of changes?
Is it the case that you wish to have multiple agents working on the same task and then picking the best implementation? Or do you have a reason to prefer multiple tasks to be implemented in complete isolation from one another?
(co-founder of gb here)
I am really sorry for the frustration - the app should do better and we will do better. In the past few months we have been putting a very deliberate effort to eliminate all conditions from which such poor experience can come about.
The work is not complete but we have stability and correctness as a primary goal, and something that is a requirement for us to declare a v1.0.
We chose not to use separate git worktrees under the hood for this functionality. Let me try to break down why, maybe there's an opportunity for me to learn more here.
In my head I separate between use cases of 1) "different tasks" and 2) "best of n, same task".
The app that we built already had the ability to separate changes into branches while in the worktree (on disk) it renders the integration of the branches. Our canonical use case back in the days was "A developer works on a feature branch and wishes to commit & publish a bugfix from separate branch". When we learned that people were using this for running multiple parallel agents we added some additional tooling for it.
So in practice what happens when you have multiple agents coding in parallel with GitButler is that the system captures information after an agent completes an edit (via the agent hooks) and uses that to 1) stage the particular edit to a branch dedicated to the agent and 2) perform a commit into that branch (GB can have multiple staging areas, one per applied branch).
The system will not allow multiple agents to edit the same file at the same time (via a locking mechanism in the pre-edit hook), but agents do see each others changes.
In the context of the "different tasks for different agents" use case, we have found that them seeing edits by others to have a positive effect on the outcomes. The first one that comes to mind is - no merge conflicts. But beyond merge conflicts, we have found that there is a lower likelihood of reaching a state where code diverges semantically.
In my own usage, I have found it helpful when I am hands on programming on something and wish to have an agent do some auxiliary task, for us to share a workspace (so that I can nudge it one way or another).
Is there something I am missing here? Of course for best-of-n of the same task this doesn't exactly make sense, but with regards to different tasks, what are some additional reasons to require full isolation? (as different worktrees would provide)
It has happened to me in the past to wonder why certain files/folders are ignored by git, only to realise that I had a global git ignore for the particular pattern.
Not sure l’d recommend this as a good default, but perhaps others have better memory than I do.
We are a small team of 9 people who love Git, building new functionality on top of the Git format (branching, code review & more). Our own @schacon has published the Pro Git book as well as co-founded GitHub.
Currently looking for Senior Software Engineers with Rust, TypeScript (frontend) or Ruby skills to join us onsite in Berlin. Job ads: https://gitbutler.homerun.co
We have been using Tauri for about a year (a desktop app) and I am very happy with our choice. What I initially found attractive was the smaller binary sizes. Over time I have come to really appreciate their stance on security and implementation of the Isolation pattern[0].
When we were deciding whether we want to build our business[1] around Tauri, the final argument that helped me decide was the video manifesto[2] on their site as I felt that we were aligned on values. Having interacted with the community over this one year I have had a very positive experience, therefore Tauri definitely gets my recommendation.
I think you are right that our documentation does not sufficiently communicate what the application does especially in various corner cases.
For my own sake, allow me to articulate the core value proposition once more. GitButler's virtual branches permit two novel use cases:
- A developer can lazily assign diffs/changes to belong to separate logical branches while maintaining their content within the same working dir. Those logical branches can be converted to plain git trees at any time. The canonical use case here is doing a bugfix while working on an unrelated feature - with the proposed workflow one can separate those contributions into discrete PRs while still having the content of both within the working dir.
- A developer can apply and unapply the content of remote branches to their working directory for the purpose of testing & review. This is distinct from rebasing and merging because it does not introduce merging or rebasing into the branch that the developer was originally working on.
In any case, we will work on communicating and documenting the tool better.
This limitation stems from the fact that GB introduces an additional dimension of versioning on top of Git. One way of thinking of what it does with virtual branches is like "multiplexing" multiple branches onto the same working directory. On the way out they get "demuxed" into plain git trees.
With that said, the tool is very cautious not to mess with any existing branches. This is the very reason it operates on a separate integration branch.
Switching between the "special/integration" branch and any other branch is also not an issue.
I think there may be a misunderstanding here. While the tool does something unorthodox locally, the output that it generates is plan Git trees that do represent a consistent snapshot.
It is the process of arriving at those snapshots (locally) that we feel we can make more ergonomic.
Disclaimer: I am a Co-founder
This article resonated with me be because I have also thought of branches as something ephemeral, with the ultimate goal of packaging and delivering a change to "prod". Perhaps this has to do with the fact that I have mostly worked on projects that have the concept of "prod".
The "what is a branch" question has been very interesting for me for a while. One alternative way of looking at it is as just semantic groupings as opposed to separate universes. For almost a year I have been working on an idea[0] of having multiple branches applied in the working directory at the same time. Why? To make it easier for me to organise my changes in small PRs (eg. bugfix, featureX, unrelated refactors etc). If anyone reading this is also into the 'what is a branch' question, I would actually like to get some critique / feedback & opinions
Currently GitButler only generates commit messages in this way (with some config options for style e.g. semantic commits). With that said, generating PR descriptions is something I was tinkering with this morning.
I quite like your diff visualisation idea, thanks for sharing. Since I am currently working on a git client (gitbutler), I'm gonna experiment a little bit to see how it feels in practice