Forky

A cross-platform Git client inspired by Fork.

Warning This software is in alpha stage. It is not recommended for use in production environments or critical projects. Expect bugs, incomplete features, and breaking changes between versions. Use at your own risk.

About

Forky is a shameless clone of Fork because I (Calambrenet) wanted a graphical Git manager that worked on Linux and looked like Fork. So I built Forky.

This project is created with no pretensions of ever being stable, but I'm using it daily for my work and I'm gradually implementing features and fixing bugs as I go.

Built with:

• Backend: Rust + Tauri 2.0 + git2 (libgit2 bindings)
• Frontend: React 19 + TypeScript + Vite
• Styling: CSS with CSS variables (dark theme)

Screenshots

Coming soon

Features

Repository Management

• Open and manage multiple Git repositories in tabs
• Auto-restore previously opened repositories on startup
• Real-time file watching with pending changes indicator
• Open repository in terminal

Commit History

• View commit history with branch graph visualization
• Navigate to specific commits
• View commit details (author, date, message, files changed)
• Diff viewer with syntax highlighting

Working Copy

• Stage/unstage individual files
• Stage/unstage all files
• View diff for staged and unstaged changes
• Commit changes with message
• Amend last commit
• Discard changes
• Partial staging (hunks)

Remote Operations

• Fetch (single remote or all remotes)
• Pull (with rebase and autostash options)
• Push (with force-with-lease and push tags options)
• Add new remote
• SSH host verification
• Credential management (username/password, SSH passphrase)
• Clone repository

Branch Operations

• View local and remote branches in tree structure
• Checkout branch (double-click or context menu)
• Create new branch (from any branch)
• Rename branch (local and remote)
• Delete branch (with force delete option, local and remote)
• Track remote branch (create local from remote)
• Copy branch name to clipboard
• Fast-forward branch

Tag Operations

• View tags in tree structure
• Create tag (lightweight or annotated)
• Push tags to remotes
• Navigate to tag commit
• Delete tag

Stash Operations

• View stash list (sidebar and dropdown)
• Create stash (with optional message and stage new files option)
• Save snapshot (stash but keep changes in working directory)
• Apply stash (apply changes, keep stash)
• Pop stash (apply changes, remove stash)
• Drop stash (remove without applying)

Git Flow

• Initialize Git Flow
• Start/finish feature
• Start/finish release
• Start/finish hotfix

Pull Requests

• View pull requests from GitHub/GitLab/Bitbucket
• Create pull request
• Review pull request

Merge, Rebase & Conflicts

• Merge branch into current
• Rebase current branch on another
• Interactive rebase
• Conflict resolution window
• Visual merge tool integration
• Abort merge/rebase

Settings & Configuration

• Settings/preferences window
• Configure keyboard shortcuts
• Configure external diff/merge tools
• Configure Git identity (name, email)

Other Features

• Multi-language support (English, Spanish, French, Italian)
• Dark theme
• Activity log for Git operations
• Keyboard shortcuts (⌘B for new branch, ⌘T for new tag)
• Filter branches/tags in sidebar
• Sort remote branches
• Light theme
• Custom themes
• Submodule support
• Cherry-pick
• Blame view
• File history

Installation

Pre-built Binaries

Pre-built binaries will be available in the Releases section once we set up the official repository.

Platform	Format
Windows	.msi, .exe
macOS Intel	.dmg (x64)
macOS Apple Silicon	.dmg (aarch64)
Linux (Debian/Ubuntu)	.deb
Linux (Universal)	.AppImage

Building from Source

Prerequisites

• Rust (stable)
• Node.js (v18 or later)
• npm or pnpm

Platform-specific Dependencies

Linux (Debian/Ubuntu):

sudo apt install libwebkit2gtk-4.1-dev build-essential curl wget file libssl-dev libayatana-appindicator3-dev librsvg2-dev

macOS:

xcode-select --install

Windows:

• Visual Studio Build Tools
• WebView2 (usually pre-installed on Windows 10/11)

Build Steps

# Clone the repository
git clone https://github.com/calambrenet/forky.git
cd forky

# Install frontend dependencies
npm install

# Run in development mode (with hot-reload)
npm run tauri dev

# Build for production
npm run tauri build

The built application will be in src-tauri/target/release/bundle/.

Development

# Run the app in development mode
npm run tauri dev

# Run only the frontend (without Tauri)
npm run dev

# Check Rust code
cd src-tauri && cargo check

# Format Rust code
cd src-tauri && cargo fmt

# Lint Rust code
cd src-tauri && cargo clippy

Version Management

The app version is centralized in package.json. The tauri.conf.json references this file, so you only need to update the version in one place.

To bump the version:

# Patch release (0.1.0 -> 0.1.1)
npm version patch

# Minor release (0.1.0 -> 0.2.0)
npm version minor

# Major release (0.1.0 -> 1.0.0)
npm version major

To access the version from the frontend:

import { getVersion } from '@tauri-apps/api/app';

const version = await getVersion(); // "0.1.0"

Contributing

Contributions are welcome! Since we don't have an official repository or website yet, here's how you can help:

1. Fork the repository
2. Create a branch for your feature or fix:

   git checkout -b feature/amazing-feature

3. Make your changes following the project conventions
4. Test your changes thoroughly
5. Commit with a descriptive message:

   git commit -m "[FEATURE] Add amazing feature"

6. Push to your fork and open a Pull Request

Please read CONTRIBUTING.md for detailed guidelines.

Code Style

• Rust: Format with cargo fmt, lint with cargo clippy
• TypeScript: Use TypeScript strict mode, avoid any
• Commits: Use prefixes like [FEATURE], [FIX], [REFACTOR], [DOCS]

Project Structure

forky/
├── src/                    # Frontend (React + TypeScript)
│   ├── components/         # UI components
│   ├── hooks/              # Custom React hooks
│   ├── stores/             # Zustand state stores
│   ├── types/              # TypeScript definitions
│   └── styles/             # Global styles
├── src-tauri/              # Backend (Rust)
│   └── src/
│       ├── git/            # Git operations (using git2)
│       ├── watcher/        # File system watcher
│       └── system/         # System utilities
└── .github/workflows/      # CI/CD pipelines

Tech Stack

Component	Technology
Framework	Tauri 2.0
Frontend	React 19
Language (Frontend)	TypeScript
Language (Backend)	Rust
Git Operations	git2 (libgit2 bindings)
Bundler	Vite
State Management	Zustand

License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

Acknowledgments

• Fork - The inspiration for this project. If you're on macOS or Windows and want a polished, stable Git client, go use Fork. It's excellent.
• Tauri - For making cross-platform desktop apps with web technologies actually good.
• libgit2 - For the Git implementation that powers this app.

Author

José Luis Castro (@calambrenet)

---

Note: This is a personal project built for my own use. It works for me, but your mileage may vary. Bug reports and contributions are welcome, but please don't expect enterprise-level support.