OurSync
v1.0.0 · GPLv3Google 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.
~/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.
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:
- Nothing can write into the middle of a file. The Drive backend implements creating a file and replacing one, streaming the bytes up in order; it implements no seek on write, no append and no truncate. So when a program asks to write at an offset, the bridge has nothing to seek, and the write fails with “operation not supported” rather than merely going slowly. A program that edits a file in place instead of rewriting it whole - most audio editors, and anything with a database inside it - does not work at all.
- There is no
mmap. The bridge does not implement it, so a program that maps a file into memory, which is again most things with a database inside them, cannot open one there. - There is nothing you can keep. It has no pin and no local copy to fall back on, so when the network goes, so does the file.
- It belongs to your login, not to the machine. The daemon takes its credentials from GNOME Online Accounts, and the mount lives in
/run/user/<uid>- the per-user runtime directory that systemd creates when you first log in and removes at your final logout. So it is there while you are logged in and gone when you are not, and at mode 700 a service running as any other user cannot see it at all. A disk does not come and go with a login.
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:
- console.cloud.google.com/projectcreate - give it any name, Create.
- console.cloud.google.com/apis/library/drive.googleapis.com - Enable.
- 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.
- console.cloud.google.com/auth/audience - under Test users, Add users, your own Google account. Without this, consent fails with
access_denied. - 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:
- Set the publishing status to “In production”, back on the overview page, once it works. A project left in Google’s Testing status has its refresh token expired after seven days, and your mount stops authenticating about a week in, for no reason you will be able to see. Production status needs no verification and no review.
- Do not upload an App logo on the Branding page. Google requires an app carrying a logo to be submitted for verification unless it stays in Testing - so the logo and the seven-day expiry come as a pair. Leave it blank.
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.
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.
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.
| Command | What 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 list | What is pinned, and what it costs on disk |
oursync refresh [path]… | Bring pinned copies back into agreement with Drive |
oursync doctor | The whole configuration, its state, and anything wrong with it |
oursync mount / unmount | Mount 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.
- No differential upload. Editing four bytes of a 2 GB file means re-uploading 2 GB. This is not laziness: no public Drive API offers a way round it - no write-at-offset, no append, no patch, no block or signature endpoint, and a revision cannot be made from a diff. Google’s own client has done it since October 2024 through something undocumented. It is the single largest thing wrong with using Drive this way, and it is why
BWLIMITexists. - Google Docs, Sheets and Slides are not files. They have no byte stream to serve, so they appear as stubs that open in the browser, and they cannot be edited through the filesystem. Drive reports them with a size of
-1and no checksum at all, so nothing can verify or compare them the way it can a real file. - A pin is a cache of Drive, not a second replica, and that one sentence settles every sync question. Drive is the truth: when
oursync refreshfinds that Drive’s copy has changed, the local copy is re-fetched. If the local copy is newer and differs, something has bypassed the mount, and that is a conflict: it is reported with both timestamps, nothing is overwritten, and the refresh exits non-zero so the timer’s run shows as failed. That is deliberate - overwriting it could destroy the only copy of something, and a conflict wants a person. Drive for desktop would make a conflict copy; this does not, yet. - Status in Nemo only, and no emblems. The right-click entries are Nemo’s. Other file managers, GTK file choosers and
lsshow no pin status at all, and no file manager shows a per-file emblem: the menu tells you what a file is, the icon does not. The mount itself works everywhere. - One account, My Drive only. A second Google account needs a second remote, union and mount, and the scripts assume one of each. Shared drives and “Shared with me” are not offered yet, and Drive’s “Computers” backup roots cannot be offered at all - the API gives no way to discover them.
- No pause. Stopping
oursync-mount.servicestops the lot; there is no pause that leaves reads working while it holds uploads.
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.