GDriveSync

Copy, mirror, and sync Google Drive folders—without the command line.

GDriveSync is an easy-to-use Linux desktop GUI for rclone. It lets you copy (or clone) folders in either direction, mirror one side to the other, and keep local and Google Drive folders synchronized both ways. Saved profiles, guided Google authorization, and required dry-run previews make powerful file-sync operations easier to set up and review.

GDriveSync is an independent project and is not affiliated with or endorsed by Google.

The application keeps Google authorization in rclone's configuration. Saved GDriveSync profiles contain folder paths and sync options, not Google passwords or OAuth tokens.

Highlights

• Named sync profiles that can be created, duplicated, renamed, and deleted
• Separate non-deleting copy and destructive mirror modes in both directions
• Two-way synchronization through rclone bisync
• A mandatory dry-run Preview changes step before Apply reviewed changes
• In-app Google OAuth setup, including access-scope and optional API credential controls
• A graphical browser for selecting folders on the connected Drive
• Planned-change, deletion, transfer, and byte activity reporting
• Bandwidth, parallel-transfer, empty-directory, exclusion, and deletion-guard options
• Graceful cancellation, with a forced stop only if rclone does not exit

Install with AppImage

Download GDriveSync-<version>-x86_64.AppImage and its checksum from the GitHub Releases page, then run:

sha256sum --check GDriveSync-*.AppImage.sha256
chmod +x GDriveSync-*.AppImage
./GDriveSync-*.AppImage

The AppImage contains GDriveSync, Python, Tk, and rclone. It does not need a system-wide install and keeps profiles and rclone credentials in the normal user configuration locations.

Tagged releases build and publish the AppImage automatically. Maintainers can also build it on an x86_64 Linux host with make appimage; see the packaging script for the pinned inputs.

Install on Arch Linux

Install the standard Arch build tools, then build and install the package as your normal user:

git clone https://github.com/Neoxplatin/GDriveSync.git
cd GDriveSync
sudo pacman -S --needed base-devel pacman-contrib
make source-archive
makepkg -si

The PKGBUILD declares the remaining build, validation, and runtime dependencies, including Python, Tk, rclone, AppStream, and desktop-file validation tools. make source-archive creates the ignored source snapshot expected by the local PKGBUILD and updates its checksum. makepkg -s asks pacman to install any missing dependencies. Do not run makepkg itself with sudo.

After package installation, launch GDriveSync from the desktop application menu or run:

gdrivesync

Run a development checkout

To run directly from source without installing:

sudo pacman -S --needed rclone python tk
PYTHONPATH=src python -m gdrivesync

The source command starts the GUI only. It does not install the gdrivesync command, desktop-menu entry, icon, or AppStream metadata.

Connect Google Drive

1. Open GDriveSync and select Manage connections in the sidebar or Connect… on the Setup page.
2. Choose a connection name and access level. Custom Google API client ID and secret values are optional; leaving them blank uses rclone's shared client.
3. Select Open Google sign-in, then approve access in the browser.
4. When authorization finishes, the new connection is selected automatically.
5. Use Browse… to navigate Drive folders, or leave the Drive folder blank to use its root.

Existing rclone remotes appear in the Google Drive selector after a refresh. Use Manage connections in the sidebar to add another account or remove a stale rclone connection; removing a connection never deletes its cloud files. Manual rclone config remains a fallback if browser authorization cannot be completed through the dialog.

Preview and apply workflow

Every transfer follows the same guarded workflow:

1. Select or create a named profile.
2. Choose the local folder, Google Drive connection, Drive folder, and sync behavior.
3. Set any advanced options.
4. Select Preview changes. This always invokes rclone with --dry-run.
5. Review planned changes, planned deletions, and detailed output on the Activity page.
6. Select Apply reviewed changes and confirm the summarized endpoints and operation counts.

Apply remains disabled until a preview completes successfully. Changing an endpoint, mode, option, exclusion, repair setting, or profile invalidates the review and requires another preview.

Preview and Apply use the same validated settings, but they are not an atomic snapshot of either filesystem. Files changed by another application between the two runs can alter what rclone ultimately does. Keep the interval short, avoid another sync against the same folders, and maintain backups for important data.

Keyboard shortcuts are available for the main actions:

• Ctrl+P: preview changes
• Ctrl+Enter: apply the reviewed changes
• Ctrl+N: create a profile
• Escape: cancel the active rclone operation

Copy, mirror, and two-way semantics

GUI mode	rclone operation	Deletion behavior
Copy to Drive	rclone copy local → Drive	Never deletes Drive-only items
Copy from Drive	rclone copy Drive → local	Never deletes local-only items
Mirror to Drive	rclone sync local → Drive	Deletes Drive-only items
Mirror from Drive	rclone sync Drive → local	Deletes local-only items
Two-way sync	rclone bisync	Propagates changes and deletions on both sides

Copy is the safest default because it does not delete destination-only files. It can still update or replace a destination file when the source has a changed file at the same path.

Mirror makes its destination match its source exactly. The preview highlights planned deletions, and the maximum-deletions option can stop a run that exceeds the configured count. Setting the guard to 0 blocks mirror deletions.

For the first two-way run, or to recover a locked or damaged bisync state, enable Initialize or repair two-way sync state on the next run. This passes --resync for that preview and Apply cycle and is deliberately not saved as a persistent profile option. In two-way mode, the deletion guard is a percentage; leaving it blank uses rclone's 50% default. A bisync safety lockout must be reviewed before using the repair option in a new preview.

Advanced options

Each named profile can save:

• Parallel transfers: from 1 to 32 concurrent file transfers
• Bandwidth limit: any rclone rate such as 8M or 500K
• Create empty source folders: carries empty directories to the destination
• Exclude patterns: one rclone pattern per line
• Deletion guard: a maximum count for mirror or percentage for two-way sync

The deletion guard is disabled for copy modes because those modes do not delete destination-only files.

Profiles, credentials, and cancellation

Profiles are saved atomically under $XDG_CONFIG_HOME/gdrivesync/profiles.json. When XDG_CONFIG_HOME is not set, the default path is:

~/.config/gdrivesync/profiles.json

Switching profiles saves the current form. GDriveSync also saves before a preview and when closing. OAuth credentials remain in rclone's own configuration and are not written to the profile file or activity log.

Cancel first sends rclone an interrupt so it can close cleanly. If rclone does not exit within a short timeout, GDriveSync terminates its process group. Closing the window during an active operation asks for confirmation and uses the same graceful cancellation path.

Development

Run the GUI and test suite with:

make run
make test

Build only the Python wheel with:

make wheel

make package remains an alias for the wheel target.

Build the self-contained AppImage with:

make appimage

The rclone-facing code is isolated in src/gdrivesync/rclone.py, so command construction, remote browsing, process state, and cancellation can be tested without starting the GUI.

Arch release workflow

The PKGBUILD uses a deterministic gdrivesync-<version>.tar.gz source snapshot. It is generated locally and ignored by Git. After changing application code, tests, README, Python metadata, desktop metadata, or packaging artwork, create or refresh it with:

make source-archive

That target recreates the archive deterministically and updates its PKGBUILD checksum and the generated, ignored .SRCINFO. It requires updpkgsums from pacman-contrib:

sudo pacman -S --needed pacman-contrib

For a final clean Arch build, use:

make arch-package

arch-package refreshes the source snapshot first, then runs:

makepkg --cleanbuild --force --noconfirm

The PKGBUILD runs the unit tests plus desktop and AppStream validation during its check() phase. A unit test keeps the version in PKGBUILD, pyproject.toml, src/gdrivesync/__init__.py, and the AppStream release metadata aligned.

The repository itself uses src/ as its Python package layout, while makepkg also reserves a directory named src/. The PKGBUILD deliberately relocates its default work directory. Do not change it back to building unchecked files from ${startdir}: a clean makepkg build would otherwise remove the working Python sources.