r/selfhosted

For the people who don't know: the Apple Time Capsule (2008-2013, rip) is basically a hard drive strapped to a wifi router. Most importantly, the hard drive part works really well for smooth Apple Time Machine backups for anyone with a Mac. Just come back home, your macbook automatically connects to wifi, and automatically starts backups.

Well, Apple's trying to kill it off with the next version of MacOS next year. Apple is removing AFP support from MacOS, which means the computer can no longer connect to the Time Capsule, which only supports AFP and SMB1. (Apple already removed SMB1 support from MacOS many years ago. SMB1 was notoriously insecure and caused the WannaCry worm).

A few months ago, I started this project, got it halfway done, got frustrated because cross compiling stuff for NetBSD6 on a Mac was painful, and stopped working on it: https://github.com/jamesyc/TimeCapsuleSMB

I'm finally finishing it up the past few days, and it's 95% done. It works! (For running Samba 4.8 with SMB3 on my Time Capsule). I can use it as a network drive in Finder, as macOS uses SMB3 to connect to it (not SMB1).

It's almost at my long term goal: hacking the Time Capsule enough that anyone who can copy some terminal commands can spend 10 minutes, and get their Time Capsule working with future versions of MacOS.

Unfortunately, due to sheer bad luck, Apple broke macOS Time Machine backups in 26.4 recently: https://www.cultofmac.com/news/macos-tahoe-26-4-breaks-time-machine-network-backups There's a workaround, but it doesn't work for everyone, and it's not working for me.

This means I can't actually properly test it. Also, I only own a A1470 generation Time Capsule, so I can't test the code on other generation devices as well.

I'm asking for some people who are a bit more on the technical side (translation: more comfortable with using the terminal than my grandmother) who have a spare Apple Time Capsule to help out with some testing. If you only have a little bit of free time, feel free to read the README in the repo and try it out. File a github issue if you run into any problems: https://github.com/jamesyc/TimeCapsuleSMB/issues

If you're willing to volunteer more time, especially if you have a mac that is NOT on 26.4, comment below what specs you have for your Time Capsule and Mac and I'll try to figure out the best strategy to quash the last few bugs.

Been working on this for a couple months. It's called Project Parva, basically an API that computes Nepali calendar stuff (BS/AD conversion, festival dates, panchanga, muhurta) using real planetary position data from Swiss Ephemeris rather than storing hardcoded dates someone typed in from a government PDF.

The main thing that bothered me about existing stuff is they all assume Kathmandu. If you're building something for diaspora users, the sunrise-dependent calculations (tithi, muhurta windows) are just wrong for anyone outside KTM. This one takes actual lat/lon.

Verified against 65 dates from MoHA holiday PDFs across 2080-2082, passes all of them.

Here's my project,
GitHub: https://github.com/dantwoashim/Project_Parva

reddit seems to flag the direct link to the API

 (AGPL, open source)
Happy to answer questions or take feedback on what's missing.

I posted Foldergram here when it first launched and got a really good response, so I wanted to share the latest update.

Foldergram is a self-hosted, local-first photo/video gallery I built for my old backup photos because I wanted something that feels more like scrolling my own old posts instead of browsing files in a traditional gallery.

It scans an existing gallery folder, indexes everything locally, generates previews/thumbnails, and gives you an Instagram-style feed, folder pages, and a post viewer. The goal is still the same: make revisiting old photos actually feel enjoyable.

Since the first public release, it has grown quite a bit. Recent updates added:

• Reels-style browsing for local videos
• Stories and highlights support from the reserved AppFolder/stories folders
• Explore search with media/folder tabs and recent searches
• Admin/Viewer/public access modes
• Original media download actions from the feed, post viewer, stories, and reels
• Better post viewer behavior and cleaner canonical routes
• Configurable excluded folders from .env or from Settings
• A new app-managed preview/thumbnail layout that is easier to maintain long-term

It is still intentionally local-only:

• no cloud sync
• no external API
• no SaaS account
• built for personal/offline or LAN use

If you tried the earlier version, this release is much more complete. I would especially love feedback from people who have used other self-hosted gallery apps and care about the browsing experience, not just file management.

Repo: https://github.com/foldergram/foldergram
Docs: https://foldergram.github.io/
Demo: https://foldergram.intentdeep.com/

TL;DR

I'm building out my self-hosted setup and would love a sanity check from the community. I'm trying to figure out if I'm using the wrong or overly complex tools for my goals, and I'm really curious to see what you all are building for similar use cases

Background:

I'm an experienced platform/infra software engineer. Some of my tooling choices might seem "complex" for a homelab, but they're actually easier for me due to professional familiarity.

My main motivation for self-hosting is having a reliable, private, and opex-efficient way to run services that make my life easier. It gives me the ick knowing my data is owned by private companies, siloed away, and tied to subscription fees. Especially when they can randomly change the rules on me based on someone else's timeline.

Some key use-cases:

• Media backups (mostly books; writings/documents, pictures)
• Data warehouse (emails, chat history, financial transactions, ...)
• Automation (e.g. autobooking gym PT)
• 2nd brain --> Eventually, I want to wire Obsidian/LLMs into a personal data warehouse so I can search through organically structured data

Stack

GitOps configuration. Any backups on 3rd party services (e.g., B2) must be encrypted client-side.

Compute

• Hardware: Single-node homelab, mini-PC.
• OS/Orchestration: Talos Linux with Secure Boot & TPM encryption keys. Kubernetes.
• Registry: Zot. A single-binary image registry. It does the job and is super low maintenance.

Storage

• Longhorn CSI (Container Storage Interface). Regret using it...it's very memory heavy. Alternatives when/if I switch:
  • local path provisioner looks neat, has single-node RWX support, but lack volume size limits
  • Some zfs/btrfs automation like https://openebs.io/?
  • Note: I originally wanted something simple to avoid Ceph/Rook, but maybe I was wrong.

File Storage: A single RWX volume (Longhorn implements it as NFS under the hood). Database: PostgreSQL (cnpg) as my main OLTP database. Most products support it, and I prefer it over SQLite just to keep cognitive overhead low. Backups: Kopia for backing up storage and databases onto Backblaze B2.

Observability

• Prometheus+vector+Loki+Tempo & Grafana:
  • I dislike their storage model, but it's good enough for now. Something like Qryn looks neat, with single analytical database to keep mind on.
• Alertmanager I seldomly check. Haven't wired up any notifications yet

Networking

• Cert-manager
• Contour ingress controller:
  • Client authN is annoying, has to be external service. Traefik's forward auth plays nicer with authentik. Maybe I'll switch eventually

Releases

Deployments: Argo CD Core Dependencies: Renovate VCS: GitHub (I'll eventually replace this with Forgejo) CI: Woodpecker CI

Security

• Secrets: 1Password for secret management, with their 1password-operator. It's neat!
• AuthN/Z: Authentik
  • It's a bit resource-heavy, but it supports a lot of features. The hope is that it will support whatever random system I want to integrate in the future (LDAP/OIDC/mTLS/etc.).

Applications

• HomeAssistant
• filebrowser
• Custom Go apps

Next steps

• S3 compatible API for data-lake. Generally I'm thinking:

  • Maybe MinIO, exposing main RWX volume as S3 API?
  • Or SeaweedFS?

• Analytical database:

  • Delta Lake or IceBerg. At a personal scale, interoperability is a much higher priority than raw "performance," thus avoiding ClickHouse.
  • Datafusion for queries. Ideally via ADBC interface. I could use CH over open table format as well.
  • Superset seems neat for visualisation; better fit over grafana for certain usecases

• Some nice low-code PostgreSQL UI

  • nocoDB ?
  • Baserow ?

• Some automation platform?

  • n8n & temporal look neat

Conclusion

What do you all think of the stack? Anything you'd swap out or do differently? (Especially interested if anyone has strong opinions on my 'Next Steps'!)

If anything stands out and you're wondering why I went with X instead of Y, just ask. I'm more than happy to jump into the comments and explain the reasoning behind my choices!

Hi! I've been working on a cross-platform CalDAV-compatible VTODO task management app for a while now since December of last year - it's called Chiri.

https://github.com/SapphoSys/chiri

The app supports:

• Subtasks, statuses (needs action, in progress, cancelled, etc), progress, tags, repeat tasks, reminders, etc
• Backwards compatibility with clients like Apple Reminders (macOS), Nextcloud Tasks, Tasks.org (Android) and DAVx5 (Android)
• Almost every CalDAV server implementation (RustiCal, Nextcloud, Baikal, Radicale)
• Managed CalDAV servers (Mailbox.org, Fastmail)
• Server auto-detection so you don't have to hunt down for the exact principal URL
• .mobileconfig files to import your CalDAV accounts

Honestly, I'm pretty happy with how it turned out and evolved compared to where it was a few months ago.

The app is still in active development, but I have been using it daily to get things done. Let me know what you think! ^^

Hi self hosters! I took on myself to make a fully open source and self hostable file sharing platform, which took shape as BluFiles!

This sports a modern and sleek interface with support for files and folders (of course), pastes and collections (groups of files for sharing). Smart uploading of files, supporting 8GB+ with high speed uploads (saturates 1000mbps at least from testing)

Sharing files is probably the main deal, with two clicks you can share files and pastes, or entire folders and "collections". You get an easy overview of your shared stuff making it simple to see what's gaining attention and to remove sharing for stuff. Shows rich information and preview of the file (for images and videos) when sending links on platforms like Discord or Slack.

Looking for feedback on this one, anything is appreciated:)

Source code: https://github.com/BluDood/BluFiles

Documentation: https://docs.files.bludood.com

Hey r/selfhosted!

I've been working on **Docksentry**, a lightweight Docker container update manager. It monitors your running containers for image updates and lets you manage them through Telegram, Discord, a Web UI, or webhooks.

**What makes it different from Watchtower?**

- **Interactive control** — Telegram bot with 14 commands, inline buttons for per-container updates

- **Auto-rollback** — if an update fails or the container becomes unhealthy, it automatically restores the previous version

- **Web UI** — full dashboard with status, logs, settings, pin/unpin, auto-update toggles (all settings persist across restarts)

- **Multi-channel** — Telegram (interactive), Discord (rich embeds), generic webhooks (Ntfy, Gotify, Home Assistant)

- **Docker Compose support** — detects Compose stacks and uses native `docker compose pull/up`

- **Pin containers** — freeze specific containers at their current version

- **16 languages** included

- **Zero dependencies** — Python standard library only, no pip packages

**Quick start:**

docker run -d \

--name docksentry \

-e BOT_TOKEN=your-token \

-e CHAT_ID=your-id \

-v /var/run/docker.sock:/var/run/docker.sock \

amayer1983/docksentry:latest

**Links:**

- GitHub: https://github.com/amayer1983/docksentry

- Docker Hub: https://hub.docker.com/r/amayer1983/docksentry

It's MIT licensed, and I'd love feedback! There's a community roadmap issue where you can vote on features: https://github.com/amayer1983/docksentry/issues/2

Hey everyone!

I've been working on DockScope, an open-source browser-based Docker dashboard.
It turns your containers into an interactive 3D graph so you can see your whole stack at a glance and manage everything from one UI.

What it does:

• 3D force graph of all your containers, color-coded by health, with dependency arrows and network links
• Live CPU/memory sparklines and network I/O, polled every 3s
• Anomaly detection that flags CPU/memory spikes with pulsing indicators on the graph and toast notifications
• Crash diagnostics that auto-analyze exit codes, OOM status, and last log lines when a container dies
• Dependency impact view (press I) to see what breaks if a container goes down. Traverses depends_on upstream and dims unaffected nodes Real-time log streaming with search and export Embedded terminal (shell into any container)
• One-click container actions: start, stop, restart, pause, kill, remove

Try it:

docker run --rm --pull always -p 4681:4681 -v /var/run/docker.sock:/var/run/docker.sock ghcr.io/manuelr-t/dockscope

Or:

npx dockscope up

Open source, MIT licensed.

GitHub: https://github.com/ManuelR-T/dockscope

Would love feedback from anyone running Compose stacks. What would make this useful for your setup?