qlyoung's wiki

degoogling - [degoogling]

qlyoung (qlyoung@undisclosed.example.com) — 2026-05-19T03:47:12+00:00

degoogling

Sometime around 2021 I began to feel that use of Google services constituted a grave threat to my digital sovereignty, and began slowly moving off of them.

Here in 2026 I still have a Google account and probably will for the foreseeable future, because Google Fi and Google Fiber remain the best cell service and internet service providers, and you need a Google account to pay for them.

Today I use my Google account for five things:

As an OAuth identity for services that require one - literally just Tailscale, I have replaced everything else with email-based accounts
Filling out Google Forms
- If you use these, please set them so they don't require a Google account
Access to shared Google Photos albums
Google Fi (cell service)
Google Fiber (internet)

Despite these limited use cases, which are all provided for free with a personal-tier Google account, I still have to pay for Google Suite ($8/month). Why? Because years ago when I wanted to use a custom domain on my Gmail account, I started paying for Google Suite to enable this functionality. When you do this, your Google account is converted from a “Personal” to a “Business” account. This is a one way transition. Once this happens, if you stop paying for it, your level of services drops *below* that offered to a free personal Google account. So until I am ready to completely disable my Google account, I have to pay Google because they don't offer a downgrade path.

Below I share what I have replaced various Google services with.

Replacements

Gmail

Migrated from Gmail first to Protonmail, and then in 2023 to Fastmail, which I am much more satisfied with. I was paying for GSuite for Business in order to use a custom domain name, now I pay Fastmail for that.

Search

I pay for Kagi.

Google Drive

Gdrive has many uses. Replacing it means replacing each function.

File sharing

Tried and rejected:

Filestash - kept running out of space on cloud VMs, S3 integration setup is a little scary, software buggy
Nextcloud - I use this on my intranet, but it's too heavy to host a separate public instance just for filesharing
magic wormhole - works, but people don't want to install programs to receive files and the mobile story is bad. shout out rymdport for favorite client.
Syncthing - Sync programs are not designed for unidirectional file transfer and don't work well for that purpose

I now pay for Dropbox. Upload to folder, share link. Sometimes you just gotta pay and move on.

Cloud storage

Okay, “cloud storage” is not really a function. There's two main reasons we use personal cloud storage:

So that we can store files in one logical “place” and then access them from any device
To save space on our devices

There's other reasons, mostly to do with reliability engineering, but those are the main two.

TL;DR I now use tiered storage; what little need I have for internet-attached storage is now met by my home server, which has a lot of storage and is always accessible via tailscale. More on that in personal infrastructure.

Google Photos

For hosting my personal photos, I initially replaced Google Photos with Photoprism. I also tried Immich and while I know this is considered heretical, it doesn't suit my needs. I ultimately gave up on server-based photo management, but that's another story.

The short of it is that I now store all my photos in a plain local directory synced across devices.

Sharing photos is more complicated. The usual situation for me is that I go on a trip with a bunch of people, and afterwards someone sets up a shared Google Photos album, everyone uploads their pictures to “the shared album”.

When you upload pictures to a “shared album”, they are in fact uploaded to your personal Google Photos account and then are published such that anyone with access to the shared album has access to those photos. Consequently you can't add photos to shared albums without storing photos in Google Photos. If you later delete those photos they disappear from the shared album.

I have tried various methods of sharing my photos with gphotos users, including:

Uploading my photos “to” the shared album, advising all participants that they will be deleted in 2 weeks, and then deleting them
Zipping the photos and sharing the zip via one of the methods described in the previous section

My current solution is to dump all my photos into a Dropbox album and send people the link. Whenever I need to free up space I delete the dropbox folder. I still have all the photos locally in my own library so I can reshare if needed.

This is much to the chagrin of people I go on group trips with, because they don't understand why I can't just use Google Photos like them and I end up being viewed as a source of inconvenience.

Google Contacts & Calendar

I run Nextcloud on my home server and have replaced G services with Nextcloud's CardDAV and CalDAV implementations. These legitimately work better than Google Calendar and Google Contacts, especially on iOS which has first class support for CardDAV and CalDAV baked into the system; consequently system apps and facilities that rely on accurate calendar and contact sync work flawlessly.

YouTube

For hosting my own videos, I have replaced it with Peertube, although my YouTube channel is still up because I haven't gotten around to wiping it yet.

Unfortunately one video I made has popped off, and since it's educational I'm a little reluctant to take it down. I will probably make a video explaining how to get to my Peertube, upload that to YouTube, and then take everything else down. Then when I finally get around to deleting my Google account, that will disappear too.

Of course I still watch videos on YouTube, and I still subscribe to channels. However, I do it via a self-hosted instance of invidious. This way all my subscription data information etc is kept on my home server. On my iPhone I use yattee as a client to my Invidious instance, so I get a YouTube app-like experience. Also has the side effect of being ad-free

Keep

See note taking programs.

Android / Play Services

Bought an iPhone.

self-hosting, technology

music_management - update to reflect current setup

qlyoung (qlyoung@undisclosed.example.com) — 2026-05-18T22:42:51+00:00

music management

I'm a big music enjoyer. What I'm not a big enjoyer of is streaming services. Maybe I'll write another article about that, but the short of it is that instead of paying a company to rent temporary access to their music library, which they pay to license from a label who in turn pays only some tiny fraction of their revenue to the artist, I prefer a more traditional model:

you find some new music
you listen to it a few times to see if you like it
if you like it, you pay the artist for a copy
you own that copy

That way the artist gets money for making art and you pay once to own a copy of it instead of renting temporary access.

Streaming is good for the first two steps. Finding new music is hard, and you have to listen to it a few times at different times, since it might only hit in a certain mood. Starting from music you already like and letting the recommender algorithm drive discovery is a good way to find new music. After that though, I prefer to pay the artist for their work instead of paying rent, and prefer to download the data once rather than every time I want to listen to it. Bandwidth is a limited resource!

One of the benefits of owning music is that you can put it on whatever device you want and use whatever program you prefer to play it. However, if you have multiple devices then getting your music collection available on all of them becomes an exercise in file management. Music also has its own inherent taxonomical structure (artist, album, label etc) that benefits from specific treatment in terms of organization. This article roughly depicts how I do all that.

Methods

Here's a chart that shows a rough outline of data flow:

flowchart LR Source -.-> |download| beet["beet import"] beet --> laptop(("fa:fa-laptop laptop")) laptop <-.-> |syncthing| desktop(("fa:fa-computer desktop")) laptop <-.-> |syncthing| W["Windows VM"] desktop <-.-> |syncthing| W W -.-> |tunefusion| phone(("fa:fa-mobile-phone phone")) W ~~~ phone click phone "<a href='https://www.dbpoweramp.com/tunefusion.htm' class='urlextern' title='https://www.dbpoweramp.com/tunefusion.htm' rel='ugc nofollow'>https://www.dbpoweramp.com/tunefusion.htm</a>"

In short:

Download the music from somewhere onto my desktop or laptop; if possible I buy it on Bandcamp
Run beet import on the downloaded music; beets cleans up tags, pulls and attaches album art, and copies the cleaned files into my “Artist/Album/<files>” library directory structure, applying my file naming scheme.

Since my music library is just a directory, it's then synced to all other devices using my syncing setup (except my phone; see below). This way it doesn't matter what device I download the music on. The arrow goes to laptop in the chart but it can go to any of them.

Playback

For playback on the computer, I prefer tauon music box.

On my iPhone, I use foobar2k. Although, it has a few drawbacks (okay just one - it doesn't support scrobbling) and in the age of AI I'll probably end up making my own when I have a few spare hours.

Phone

The phone is a little tricky. Ideally I would use the same approach as for my desktop and laptop - run a sync program to keep the music library up to date on my iPhone disk. Unfortunately, that's not how things work on iOS, for two reasons:

background daemons cannot really exist on iOS
the concept of a filesystem that is shared between apps does not exist on iOS

Regarding backgrounding, in general iOS is very strict about apps performing any work in the background. Since sync programs are designed around running in the background, this more or less precludes the file synchronization strategy. This could be worked around using iCloud, but I don't use iCloud.

Even if a sync program was viable on iOS, we would hit another blocker. iOS does not have the concept of a shared filesystem. Apps may only write to their sandboxed filesystems. Consequently any files downloaded by a sync app would not be accessible by a music player app.

The upshot is that to solve this problem you need a music playback app that also has its own syncing service built in. Obviously this is heretical. A music player should focus solely on playing music, while a syncing application should handle data sync. The result of that being impossible is the app store has a bunch of terrible apps with names like “Network music player ULTIMATE” that have varying levels of support for playback and/or sync to/from various data sources - Samba, WebDAV, whatever else you can think of. I've tried most of them and they all suck.

I can already hear you saying, “why don't you just stream your music from home using a player”? In addition to the available apps sucking, network conditions on mobile are variable enough that streaming from a home server results in a generally poor experience. Industrial streaming services like Spotify have to go to extreme lengths to paper over the network enough to deliver a good experience. “Pinning” - where you stream but select specific items to keep locally on disk - doesn't really work for me because I don't want to choose what music to listen each time I anticipate a no-network scenario.

Anyway, as luck would have it, the best music player on iOS also has the best sync solution I've seen. The downside is that the companion program that runs on your server

is Windows only
is closed source
costs money

However, it is surprisingly full featured and works very well. Since it's Windows only, I run it inside a windows VM on my hypervisor (which also hosts the file server with my music library). The VM has the music directory mounted from the file server via Samba.

The end result is that every time I open the foobar2000 app on iOS, any new music in my library downloads to my device. After that it's available for local playback. Since my phone is also on Tailscale, this works anywhere.

Historical methods

I used to do it a much more complicated way than depicted above because I had an Android phone with not enough storage to store my lossless music collection. Android meant I could run background file syncing utilities and not enough storage meant that I had to transcode my collection to something lossy in order to crunch it down small enough to fit on my phone. Buying an iPhone with 512gb of storage meant that 1) I lost the ability to run any kind of background syncing software because iOS doesn't really allow daemons to exist (unless Apple made them) and 2) I no longer needed to transcode as my music collection is only ~115gb which fits on my phone's internal storage. Thus all of the automatic cron jobs to do periodic transcoding and sync via syncthing etc are no more.

These are the unintelligible notes I took about how I used to do it, replete with ascii diagrams from a time before I caved a little bit on my static site elitism and just used mermaid:

1. Tx from source to local staging directory 2. `beet import` from staging directory into mounted remote share[0]

                 { source }
                     |
                     .
                    ---   (net) <1>
                     .
                     |
                     v
              [ local:music ]
                     |
                     .
            beet    ---   (net) <2>
           import    .
                     |
                     v
      [ remote:music => local:remote/music]

3. cron job on remote periodically copies new files into a sync directory,

 transcoding any lossless files to `-q6` ogg vorbis to reduce size[1]

             [ remote:music ]
                     |
                     |
    music-sync.sh    |    @ 2hr <3>
                     |
                     v
           [ remote:music-sync ]

4. sync directory shared to all devices via syncthing[2]

           [ remote:music-sync ]
                     |
                     |
                     .
        syncthing   ---   (net) <4>
                     .
                    ...
                   . . .
                  .  .  .
                 .   .   .
                /    |    \
               v     v     v
            phone  laptop  idk

[0] <https://beets.io/>

[2] <https://syncthing.net/>

#!/usr/bin/fish
set MUSICDIR "./music/"
set SYNCDIR  "./music-sync"
 
for dir in (find "$MUSICDIR" -type d | cut -d'/' -f3-)
    mkdir -p "$SYNCDIR/$dir"
end
 
for file in (find "$MUSICDIR" -type f -name '*.flac' -o -name '*.mp3' -o -name '*.ogg' | cut -d'/' -f3-)
    set ifile (echo "$MUSICDIR/$file")
    switch $file
    case "*.flac"
        set ofile (echo "$SYNCDIR/"(echo "$file" | sed "s/flac/ogg/"))
        if test -e "$ofile"
            echo "$ofile exists; skipping"
            continue
        end
        echo ">> Transcoding '$ifile' to '$ofile'"
        oggenc -q6 -o "$ofile" "$ifile"
    case "*"
        set ofile (echo "$SYNCDIR/$file")
        if test -e "$ofile"
            echo "$ofile exists; skipping"
            continue
        end
        echo ">> Copying '$ifile' to $ofile"
        cp "$ifile" "$ofile"
    end
end

from blog, technology, self-hosting

start

qlyoung (qlyoung@undisclosed.example.com) — 2026-05-18T03:39:33+00:00

home page

this my wiki, here you will find many things i wish to write about.

Tag	Quantity
from blog	10
diving	4
technology	14
self-hosting	4
nature	2
making	1
networking	1
photography	1
programming	2
products	1
literature	1
humanity	6
pithy	1
stupid	1
food	1
philosophy	2
gambling	1
complaining	1
flexing	1
machine learning	1
geospatial	1

youtube_pro_tips - created

qlyoung (qlyoung@undisclosed.example.com) — 2026-05-18T03:36:49+00:00

before:<year> is a working filter
http://astronaut.io/
https://invidious.io/
- https://github.com/yattee/yattee can use invidious as a client; this is how i use youtube on ios without ads or the youtube app