timeliner VS boringproxy

Heya! I'm the author of PhotoStructure, and my Google Photos account (before I started working on PhotoStructure) is about that size, too.

I wrote up some tips here: https://photostructure.com/faq/takeout/

This is what I did:

1. First try to fetch all your Google Photos via Takeout in one archive. If it fails (like it did for me), try different-sized .tgz archives. I had to use the 10 Gb option (using 50gb caused an internal-to-google error).

If that fails to work, the last resort is to manually create by-year albums, shove all photos from that year into that album, and do a takeout of just that album. Repeat as necessary for every year.

2. Install an app on your phone to *directly* upload the original photos and videos from your phone to your NAS/home server. I have several recommended apps here: https://photostructure.com/faq/how-do-i-safely-store-files/#...

At this point, you can still use Google Photos (for viewing and as a last-ditch backup), but your originals are safe (without all the Google Photo downsampling and metadata shenanigans), and you're free to use whatever self-hosted software you want (like PhotoStructure, but there are a ton of alternatives, as well).

FWIW, I also tried this software: https://github.com/mholt/timeliner -- it does what it can, but the files you get via the API has a bunch of metadata stripped from it. I even had captured-at times get mangled with older photos.

This is why I'm building Timelinize [1]. It's a follow-up to my open source Timeliner project [2], which has the potential to download all your digital life onto your own computer locally, and projects it all onto a single timeline, across all data sources (text messages, social media sites, photos, location history, and more).

It's a little different from "self hosting" but it does have a similar effect of bringing all your data home and putting it in your control.

The backend and underlying processing engine is all functional and working very well; now I'm just getting the UI put together, so I hope to have something to share later this year.

[1]: https://twitter.com/timelinize (website coming eventually)

[2]: https://github.com/mholt/timeliner

Not a "big project/service" but a Go project that uses Sqlite is one of my own, Timeliner[1] and its successor, Timelinize[2] (still in development). Yeah the cgo dependency kinda sucks but you don't feel it in code, just compilation. And it easily manages Timeline databases of a million and more entries just fine.

[1]: https://github.com/mholt/timeliner

[2]: https://twitter.com/timelinize

This looks promising but might be a bit complicated for you: https://github.com/mholt/timeliner

I made Timeliner to download my Google Photos: https://github.com/mholt/timeliner -- requires some tech prowess for now, though.

A couple of years ago I've read about this concept (already forgot the name) of using self hosted data storage with cloud applications. Basically, you as a user own your data and only permit the cloud hosted web application to access it - not own it and manage in your place.

I was thinking of a similar concept, but in the context of mobile applications. The mobile application itself would be accessible via Google Play Store/App Store, but the backend part would be self hosted and upon opening the application you would have to specify how to access backend.

My question is how would I access the backend if it was hosted on let's say rpi running in the living room? It's not a problem as long as I'm within the home network, but I want seemless network transition without losing access when entering/leaving the house. I was told https://www.cloudflare.com/en-gb/products/zero-trust/access/ could be used for this, but to me it sounds a bit of an overkill to use it for an application which would never be used by more than a single digit amount of users. This looks more suitable: https://github.com/boringproxy/boringproxy

Finally, someone in the above project's Matrix room directed me towards boringproxy - https://github.com/boringproxy/boringproxy. This was the perfect solution. No lengthy config files, easy to use and automate. Setup took about an hour and now everything is back up and running. The only issue I've currently not been able to solve is one where the container seems to use a websocket, which keeps getting timed out (will investigate this further tomorrow).

boringproxy (GitHub) is my go-to for this sort of thing. Thanks for the announcement, I'll have to do a head-to-head and see how they stack up!

boringproxy

Am I the only one who thinks SQLite is still too complicated for many programs? Maybe it's just the particular type of software I normally work on, which tends towards small, self-hosted networking services[0] that would often have a single user, or maybe federated with <100 users. These programs need a small amount of state for things like tokens, users accounts, and maybe a bit of domain-specific things. This can all live in memory, but needs to be persisted to disk on writes. I've reached for SQLite several times, and always come back to just keeping a struct of hashmaps[1] in memory and dumping JSON to disk. It's worked great for my needs.

Now obviously if I wanted to scale up, at some point you would have too many users to fit in memory. But do programs at that scale actually need to exist? Why can't everyone be on a federated server with state that fits in memory/JSON? I guess that's more of a philosophical question about big tech. But I think it's interesting that most of our tech stack choices are driven by projects designed to work at a scale most of us will never need, and maybe nobody needs.

[0]: https://boringproxy.io/

[1]: https://github.com/boringproxy/boringproxy/blob/master/datab...

This is the commit that seems to have broken the docker image.

I use https://github.com/boringproxy/boringproxy