Software

OurSync

v1.0.0 · GPLv3

Google Drive on Linux Mint: your whole Drive at ~/Drive as an ordinary folder, streamed as you read it, synchronised both ways, with the files you choose kept on local disk. What Drive for desktop does on Windows and macOS, on the platform Google never shipped it for.

A Nemo file-manager window on the Drive folder in Linux Mint.
Drive, mounted at ~/Drive on Linux Mint, in Nemo.

Download

Free software, under the GPL, for Linux Mint 22 and Ubuntu 24.04 or newer. It needs fuse3, which apt has, and a current rclone, which apt does not - one command before the package.

oursync_1.0.0_all.deb · 0.5 MB, 2026-11-19 · release notes · SHA256SUMS · source on GitHub

Then oursync setup, once, for each person who uses the machine - and before that, the Google Cloud project it needs, which is ten minutes of clicking and the only awkward part of the whole thing.

Built from the newest public release of reckless-technology/oursync at every deploy (tools/release.py in pages.yml). While the only release is a draft, GitHub's releases/latest answers 404, so no release is read and this says the first is coming; publishing one makes the next deploy link its .deb, with no edit here.

What it does

Your Drive appears at ~/Drive as an ordinary directory tree, and every program on the machine can read it: a file manager, a DAW, ls, anything. Nothing is downloaded until something reads it, so a Drive far larger than the disk costs nothing to mount - 5 TB on a 500 GB laptop is the case it was built for. What has been read is cached, and evicted as the cache fills.

A file that must always be fast, or must survive going offline, is pinned: a real copy is placed on local disk, served from there, and never evicted. That is the one thing OurSync adds. Streaming a Drive through a mount is what rclone mount has done for years; what rclone has no way to say is keep this one, because its cache evicts by age and size and will throw out the file you care about to make room for one you opened once.

It syncs both ways. Save a file under ~/Drive and it uploads; delete one and it goes to Drive’s trash; rename one and it is renamed in Drive. Change something in Drive from the web, a phone or another machine and a streamed file picks it up within the minute, while a pinned file is brought up to date by oursync refresh, which a timer runs every five minutes.

Underneath, it is a few hundred lines of shell over rclone, and the whole design is two upstreams consulted in order:

~/Drive                     an rclone mount of a union remote
  └─ union                  two upstreams, consulted in configured order
       ├─ <pin dir>:nc      local disk - a pinned file is served from here
       └─ gdrive-own:       Drive itself

A read takes the first upstream that holds the path, so a pin wins deterministically rather than by winning a race. A write to a file both hold goes to both, so a pinned copy cannot silently drift from the copy in Drive. And :nc means nothing is ever created on local disk by accident: a new file written into the mount goes to Drive, where it belongs, and a pin is placed deliberately or not at all.

But Nemo already shows my Drive

It does, and for browsing, that is often enough. Mint’s file manager can show a Google account’s Drive through GNOME Online Accounts and GVfs, and if what you want is to look through Drive and open the odd document, it works and you do not need this.

The difference is that GVfs is not a filesystem. It is an extension to GIO, GNOME’s file library: programs written against GIO talk to the gvfsd daemon over D-Bus, and everything else - a DAW, a compiler, a backup tool, ls - reaches it only through a bridge, gvfsd-fuse, mounted inside your session’s own runtime directory at /run/user/<uid>/gvfs/. The bridge covers a useful part of what a disk does, and the parts it leaves out are the ones that matter to a program rather than to a person:

OurSync mounts Drive as an ordinary FUSE filesystem at a path that does not move, so every program on the machine sees it the same way and a pinned file is a real file on the disk. The one thing it does not fix is Google’s own documents: GVfs shows them as shortcuts that open in the browser, and OurSync shows them as stubs that do the same, because neither can turn a Google Doc into a stream of bytes.

None of which is a complaint about GVfs. It solves the problem it set out to solve - letting a file manager browse a cloud account - and it does that without asking you to create a Cloud project, which is the next thing on this page.

Before you install: your own Google Cloud project

This is the part that takes the time - about ten minutes of clicking in Google’s console, once. It cannot be skipped, and it is worth knowing why before you start.

OurSync ships no OAuth client ID, and never will. Seeing a whole Drive needs Google’s restricted drive scope, and an application that distributes its own client ID with a restricted scope needs OAuth verification plus an annually renewed third-party security assessment - a five-figure yearly cost that no free tool is going to carry. A client from your own Cloud project falls under Google’s documented personal-use exemption instead: no verification, no assessment, and an API quota nobody else is sharing. Your credential, your project, your quota.

Once, in your browser. Every page after the first wants your new project selected, which it will be once you have made it:

  1. console.cloud.google.com/projectcreate - give it any name, Create.
  2. console.cloud.google.com/apis/library/drive.googleapis.com - Enable.
  3. console.cloud.google.com/auth/overview - Get started. What used to be called the OAuth consent screen is now the Google Auth Platform: an app name, your own email as the support contact, Audience External, a contact email, agree.
  4. console.cloud.google.com/auth/audience - under Test users, Add users, your own Google account. Without this, consent fails with access_denied.
  5. console.cloud.google.com/auth/clients/create - Application type Desktop app, Create, then Download JSON from the client you have just made.

Save that file as ~/.config/oursync/client_secret.json, and oursync setup will take it from there. You will see an unverified app warning when you consent: that is expected, because the app is yours and you have not paid Google to verify it.

Two traps are worth calling out, because each one bites later rather than now:

Installing it

The package is for Linux Mint 22 and Ubuntu 24.04 or newer, and their kin. It mounts through FUSE, so it needs fuse3, which apt has - and it needs rclone 1.67 or newer, but not 1.68.0, which apt does not.

Mint 22 and Ubuntu 24.04 ship rclone 1.60.1, and that is not enough, so install the current one first. It is rclone’s own recommended route and takes a few seconds:

curl https://rclone.org/install.sh | sudo bash

Then the package itself:

sudo apt install ./oursync_*_all.deb
oursync setup                                        # once per user
systemctl --user enable --now oursync-mount.service  # mount it now and at every login
systemctl --user enable --now oursync-refresh.timer  # keep pinned files up to date
oursync doctor                                       # check it over

That rclone floor is measured rather than guessed, and it is not a straight line, which is why OurSync checks it itself and refuses to mount rather than let either failure happen quietly - both are silent. A test in the repository exercises every rclone feature OurSync depends on, run against rclone’s own release binaries from 1.60.1 to 1.76.0. Below 1.67, a save to a pinned file reaches Drive but not the local copy, so the mount goes on serving what you have just overwritten. 1.68.0 alone cannot read the mount’s control-port address from the environment, and OurSync will not put that password on a command line instead, where ps would show it to every account on the machine. The package carries no version on its rclone dependency on purpose: PATH decides which rclone runs, and dpkg cannot see the one that install.sh puts in /usr/local/bin.

oursync setup is the half a package cannot do: a .deb installs once for a machine, while a Drive token belongs to a person, so each user runs it for themselves. It creates the Drive remote, the union over it, the configuration file and the pin directory, and it walks you through the Google step above if there is no remote yet. It is safe to re-run, and it will not overwrite a configuration file you already have.

If you would rather it could only read, oursync setup --scope drive.readonly installs a read-only Drive, and the mount is then made read-only to match, so a write fails at once instead of being refused by the API half-way through a save. oursync setup --scope drive turns a read-only installation into one that can write; Google binds the scope to the token, so that asks for consent again.

oursync doctor prints the whole configuration and its state - the versions, the remote and its scope, the union’s upstreams, whether the mount is up and whether it can be written to, how many files are pinned and what they cost, the cache and its limit, the refresh timer and the free space - and then says either what is wrong or that nothing is. It is the first thing to run when something looks odd.

Using it

Mostly you do not. Drive is a folder, and the folder works: open it in a file manager, point a program at it, or cd into it. Nothing in it is on the disk until something reads it.

Keeping a file on the disk

Right-click a file or a folder under ~/Drive in Nemo and choose Make available offline. A real copy is fetched to local disk, and from then on it is served from there: reads never touch the network, and the cache can never evict it.

Nemo's right-click menu on a streamed file, showing the entry Make available offline.
A streamed file: the menu offers Make available offline.

The same menu on a file that is already kept offline offers the opposite, and only that one - the two entries are gated so that each appears where it applies and neither appears outside the mount. Remove local copy gives the disk space back; the file stays in Drive and streams when it is next opened.

Nemo's right-click menu on a pinned file, showing the entry Remove local copy.
The same menu on a pinned file: Remove local copy instead.

The same thing, from a terminal

oursync status says which a file is, oursync pin and oursync unpin change it, and oursync list shows everything kept on disk and what it costs. A folder can be pinned as a folder, and then it keeps up with whatever Drive puts in it.

A terminal session: oursync status on three files, oursync pin on one of them, and oursync list showing four pinned files totalling 239 MB.
The pictures on this page were taken of a test installation over invented files, on Linux Mint 22.3.
CommandWhat it does
oursync pin <path>…Keep a real copy on disk; reads never touch the network again
oursync unpin <path>…Remove the local copy; the file goes back to streaming
oursync status <path>…Pinned or streamed
oursync listWhat is pinned, and what it costs on disk
oursync refresh [path]…Bring pinned copies back into agreement with Drive
oursync doctorThe whole configuration, its state, and anything wrong with it
oursync mount / unmountMount Drive by hand, or unmount it
oursync setup [--scope S]Create or re-authorise the per-user configuration

unpin checks that Drive really still has the file before it deletes the local copy, and refuses if it does not, because then the copy on your disk is the only one.

What keeps it all up

Two systemd user units do the work: oursync-mount.service mounts Drive at login and keeps it mounted, and oursync-refresh.timer runs oursync refresh every five minutes. Refresh is what carries a change made to Drive elsewhere - the web, a phone, another machine - into a pinned copy, which the mount would otherwise never notice, because it serves the local copy without asking Drive. A streamed file needs none of this: it picks a remote change up within the minute.

Settings live in ~/.config/oursync/oursync.conf, in shell syntax, and the ones worth knowing are the cache ceiling (CACHE_MAX_SIZE, 20 GB by default) and its age (CACHE_MAX_AGE, 72 hours), how long a closed file waits before it is uploaded (WRITE_BACK, ten seconds, so an application that saves five times spends one upload), and BWLIMIT, which is worth setting on a slow uplink for the reason in the next section.

What it does not do

These are the ones to know before you install rather than after. The repository has the full feature-by-feature comparison with Drive for desktop, each row saying how it was established.

Source and licence

OurSync is free software under the GNU General Public License, version 3 or later, and the whole of it - the scripts, the package, the tests and the notes that record how each decision was measured - is at github.com/reckless-technology/oursync. It is not a Google product and it is not affiliated with Google. It collects nothing about you and sends nothing to us, as the privacy statement says; every product’s licence is on the licences page. Questions, bugs and ideas are welcome at hello@recklesstechnology.com.