Tag: programming

Anki Sync Server Enhanced — Now Available as a TrueNAS App

February 7th, 2026

🎴 Open Source · Self-Hosted

Take full control of your Anki flashcard syncing. A self-hosted sync server with user management, TLS, backups, and metrics — packaged for one-click install on TrueNAS.

Why Self-Host Your Anki Sync?

Anki is the gold standard for spaced repetition learning — used by medical students, language learners, and lifelong learners worldwide. By default, Anki syncs through AnkiWeb, Anki’s official cloud service. But there are good reasons to run your own sync server: full ownership of your data, no upload limits, the ability to share a server with a study group, and the peace of mind that comes with keeping everything on your own hardware.

Anki Sync Server Enhanced wraps the official Anki sync binary in a production-ready Docker image with features you’d expect from a proper self-hosted service — and it’s now submitted to the TrueNAS Community App Catalog for one-click deployment.

What’s Included

🔐

User Management

Create sync accounts via environment variables. No database setup required.

🔒

Optional TLS

Built-in Caddy reverse proxy for automatic HTTPS with Let’s Encrypt or custom certs.

💾

Automated Backups

Scheduled backups with configurable retention and S3-compatible storage support.

📊

Metrics & Dashboard

Prometheus-compatible metrics endpoint and optional web dashboard for monitoring.

🐳

Docker Native

Lightweight Debian-based image. Runs as non-root. Healthcheck included.

⚡

TrueNAS Ready

Submitted to the Community App Catalog. Persistent storage, configurable ports, resource limits.

How It Works

Anki Desktop / Mobile → Anki Sync Server Enhanced → TrueNAS Storage

Your Anki clients sync directly to your TrueNAS server over your local network or via Tailscale/WireGuard.

The server runs the official anki-sync-server Rust binary — the same code that powers AnkiWeb — inside a hardened container. Point your Anki desktop or mobile app at your server’s URL, and syncing works exactly like it does with AnkiWeb, just on your own infrastructure.

TrueNAS Installation

Once the app is accepted into the Community train, installation is straightforward from the TrueNAS UI. In the meantime, you can deploy it as a Custom App using the Docker image directly.

PR Status: The app has been submitted to the TrueNAS Community App Catalog via PR #4282 and is awaiting review. Track progress on the app request issue #4281.

To deploy as a Custom App right now, use these settings:

Setting	Value
Image	`chrislongros/anki-sync-server-enhanced`
Tag	`25.09.2-1`
Port	`8080` (or any available port)
Environment: `SYNC_USER1`	`yourname:yourpassword`
Environment: `SYNC_PORT`	Must match your chosen port
Storage: `/data`	Host path or dataset for persistent data

Connecting Your Anki Client

After the server is running, configure your Anki client to use it. In Anki Desktop, go to Tools → Preferences → Syncing and set the custom sync URL to your server address, for example http://your-truenas-ip:8080. On AnkiDroid, the setting is under Settings → Sync → Custom sync server. On AnkiMobile (iOS), look under Settings → Syncing → Custom Server.

Then simply sync as usual — your Anki client will talk to your self-hosted server instead of AnkiWeb.

Building It: Lessons from TrueNAS App Development

Packaging a Docker image as a TrueNAS app turned out to involve a few surprises worth sharing for anyone considering contributing to the catalog.

TrueNAS apps use a Jinja2 templating system backed by a Python rendering library — not raw docker-compose files. Your template calls methods like Render(values), c1.add_port(), and c1.healthcheck.set_test() which generate a validated compose file at deploy time. This means you get built-in support for permissions init containers, resource limits, and security hardening for free.

One gotcha: TrueNAS runs containers as UID/GID 568 (the apps user), not root. If your entrypoint writes to files owned by a different user, it will fail silently or crash. We hit this with a start_time.txt write and had to make it non-fatal. Another: the Anki sync server returns a 404 on / (it has no landing page), so the default curl --fail healthcheck marks the container as unhealthy. Switching to a TCP healthcheck solved it cleanly.

The TrueNAS CI tooling is solid — a single ci.py script renders your template, validates the compose output, spins up containers, and checks health status. If the healthcheck fails, it dumps full container logs and inspect data, making debugging fast.

Get Involved

Ready to Self-Host Your Anki Sync?

Deploy it on TrueNAS today or star the project on GitHub to follow development.

GitHub Repository Docker Hub TrueNAS PR #4282

Anki TrueNAS Self-Hosted Docker Spaced Repetition Open Source Homelab

r-fsrs: R bindings for the FSRS algorithm

January 17th, 2026
As someone who uses Anki extensively for medical studies, I’ve always been fascinated by the algorithms that power spaced repetition. When the FSRS (Free Spaced Repetition Scheduler) algorithm emerged as a more accurate alternative to Anki’s traditional SM-2, I wanted to bring its power to the R ecosystem for research and analysis.

The result is rfsrs — R bindings for the fsrs-rs Rust library, now available on r-universe.

Install it now:
install.packages("rfsrs", repos = "https://chrislongros.r-universe.dev")

What is FSRS?

FSRS is a modern spaced repetition algorithm developed by Jarrett Ye that models memory more accurately than traditional algorithms. It’s based on the DSR (Difficulty, Stability, Retrievability) model of memory:
- Stability — How long a memory will last (in days) before dropping to 90% retrievability
- Difficulty — How hard the material is to learn (affects stability growth)
- Retrievability — The probability of recalling the memory at any given time
FSRS-6, the latest version, uses 21 optimizable parameters that can be trained on your personal review history to predict optimal review intervals with remarkable accuracy.

The Rating Scale

FSRS uses a simple 4-point rating scale after each review:

1

Again

Blackout

2

Hard

Struggled

3

Good

Correct

4

Easy

Effortless

Why Rust + R?

The reference implementation of FSRS is written in Rust (fsrs-rs), which provides excellent performance and memory safety. Rather than rewriting the algorithm in R, I used rextendr to create native R bindings to the Rust library.

This approach offers several advantages:
- Performance — Native Rust speed for computationally intensive operations
- Correctness — Uses the official, well-tested implementation
- Maintainability — Updates to fsrs-rs can be easily incorporated
- Type Safety — Rust’s compiler catches errors at build time
Architecture

Here’s how rfsrs connects R to the Rust library:

rfsrs Architecture

R Layer

fsrs_default_parameters() fsrs_initial_state() fsrs_next_state() fsrs_retrievability()

▼

rextendr Bridge

R → Rust

Vectors → Vec, Lists → structs

Rust → R

f64 → numeric, structs → lists

▼

Rust Layer (fsrs-rs)

Algorithm

FSRS-6, 21 params

MemoryState

stability, difficulty

Functions

next_states(), etc.

Usage Examples

Getting Started
```
library(rfsrs)

# Get the 21 default FSRS-6 parameters
params <- fsrs_default_parameters()

# Create initial memory state (rating: Good)
state <- fsrs_initial_state(rating = 3)
# $stability: 2.3065
# $difficulty: 2.118104
```
Tracking Memory Decay
```
# How well will you remember?
for (days in c(1, 7, 30, 90)) {
  r <- fsrs_retrievability(state$stability, days)
  cat(sprintf("Day %2d: %.1f%%\n", days, r * 100))
}
# Day  1: 95.3%
# Day  7: 76.4%
# Day 30: 49.7%
# Day 90: 26.5%
```
Note: Stability of 2.3 days means memory drops to 90% retrievability after 2.3 days. This increases with each successful review.

Use Cases for R
- Research — Analyze spaced repetition data with R’s statistical tools
- Visualization — Plot memory decay curves with ggplot2
- Integration with ankiR — Combine with ankiR to analyze your Anki collection
- Custom schedulers — Build spaced repetition apps in R/Shiny
Building Rust + R Packages

The rextendr workflow:
1. Create package with usethis::create_package()
2. Run rextendr::use_extendr()
3. Write Rust with #[extendr] macros
4. Run rextendr::document()
5. Build and check
Windows builds: Cross-compiling Rust for Windows can be tricky. My r-universe builds work on Linux and macOS but fail on Windows. Windows users can install from source with Rust installed.

Resources
- rfsrs on r-universe
- rfsrs on GitHub
- fsrs-rs — The Rust library
- ABC of FSRS — Algorithm intro
- rextendr — R + Rust bindings
What’s Next

Future plans include parameter optimization (training on your review history), batch processing, and tighter ankiR integration.

If you’re interested in spaced repetition or memory research, give rfsrs a try. Feedback welcome!
Contributing to Open Source: Creating Packages for FreeBSD and Arch Linux

January 11th, 2026
A journey through packaging Python libraries for spaced repetition and Anki deck generation across multiple platforms.

As someone passionate about both medical education tools and open-source software, I recently embarked on a project to make several useful Python libraries available as native packages for FreeBSD and Arch Linux. This post documents the process and shares what I learned along the way.

The Motivation

Spaced repetition software like Anki has become indispensable for medical students and lifelong learners. However, the ecosystem of tools around Anki—libraries for generating decks programmatically, analyzing study data, and implementing scheduling algorithms—often requires manual installation via pip. This creates friction for users and doesn’t integrate well with system package managers.

My goal was to package three key Python libraries:
- genanki – A library for programmatically generating Anki decks
- fsrs – The Free Spaced Repetition Scheduler algorithm (used in Anki and other SRS apps)
- ankipandas – A library for analyzing Anki collections using pandas DataFrames
Arch Linux User Repository (AUR)

The AUR is a community-driven repository for Arch Linux users. Creating packages here involves writing a PKGBUILD file that describes how to fetch, build, and install the software.

python-fsrs 6.3.0

The FSRS (Free Spaced Repetition Scheduler) algorithm represents the cutting edge of spaced repetition research. Version 6.x brought significant API changes, including renaming the main FSRS class to Scheduler.
```
# PKGBUILD for python-fsrs
pkgname=python-fsrs
pkgver=6.3.0
pkgrel=1
pkgdesc="Free Spaced Repetition Scheduler algorithm"
arch=('any')
url="https://github.com/open-spaced-repetition/py-fsrs"
license=('MIT')
depends=('python' 'python-typing_extensions')
makedepends=('python-build' 'python-installer' 'python-wheel' 'python-setuptools')
source=("https://files.pythonhosted.org/packages/source/f/fsrs/fsrs-${pkgver}.tar.gz")
sha256sums=('3abbafd66469ebf58d35a5d5bb693a492e1db44232e09aa8e4d731bf047cd0ae')

build() {
    cd "fsrs-$pkgver"
    python -m build --wheel --no-isolation
}

package() {
    cd "fsrs-$pkgver"
    python -m installer --destdir="$pkgdir" dist/*.whl
    install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
}
```
The package is now available at: aur.archlinux.org/packages/python-fsrs

python-genanki 0.13.1

genanki allows developers to create Anki decks programmatically—perfect for generating flashcards from databases, APIs, or other structured data sources.

Package available at: aur.archlinux.org/packages/python-genanki

python-ankipandas 0.3.15

ankipandas provides a pandas-based interface for reading and analyzing Anki collection databases, enabling data science workflows on your study data.

Package available at: aur.archlinux.org/packages/python-ankipandas

FreeBSD Ports Collection

FreeBSD’s ports system is more formal than the AUR, with stricter guidelines and a review process. Ports are submitted via Bugzilla and reviewed by committers before inclusion in the official ports tree.

py-genanki Port

Creating a FreeBSD port required several steps:
1. Setting up the port skeleton – Creating the Makefile, pkg-descr, and distinfo files
2. Handling dependencies – Mapping Python dependencies to existing FreeBSD ports
3. Patching setup.py – Removing the pytest-runner build dependency which doesn’t exist in FreeBSD ports
4. Testing the build – Running make and make install in a FreeBSD environment
The final Makefile:
```
PORTNAME=       genanki
PORTVERSION=    0.13.1
CATEGORIES=     devel python
MASTER_SITES=   PYPI
PKGNAMEPREFIX=  ${PYTHON_PKGNAMEPREFIX}

MAINTAINER=     chris.longros@gmail.com
COMMENT=        Library for generating Anki decks
WWW=            https://github.com/kerrickstaley/genanki

LICENSE=        MIT
LICENSE_FILE=   ${WRKSRC}/LICENSE.txt

RUN_DEPENDS=    ${PYTHON_PKGNAMEPREFIX}cached-property>0:devel/py-cached-property@${PY_FLAVOR} \
                ${PYTHON_PKGNAMEPREFIX}chevron>0:textproc/py-chevron@${PY_FLAVOR} \
                ${PYTHON_PKGNAMEPREFIX}frozendict>0:devel/py-frozendict@${PY_FLAVOR} \
                ${PYTHON_PKGNAMEPREFIX}pystache>0:textproc/py-pystache@${PY_FLAVOR} \
                ${PYTHON_PKGNAMEPREFIX}pyyaml>0:devel/py-pyyaml@${PY_FLAVOR}

USES=           python
USE_PYTHON=     autoplist distutils

.include <bsd.port.mk>
```
One challenge was that genanki’s setup.py required pytest-runner as a build dependency, which doesn’t exist in FreeBSD ports. The solution was to create a patch file that removes this requirement:
```
--- setup.py.orig       2026-01-11 15:32:48.887894000 +0100
+++ setup.py    2026-01-11 15:32:51.336128000 +0100
@@ -27,9 +27,6 @@
         'chevron',
         'pyyaml',
       ],
-      setup_requires=[
-          'pytest-runner',
-      ],
       tests_require=[
           'pytest>=6.0.2',
       ],
```
py-fsrs Port

The FSRS port followed a similar pattern, with its own set of dependencies to map to FreeBSD ports.

Both ports are available in my GitHub repository and have been submitted to FreeBSD Bugzilla for review:
- py-genanki branch
- py-fsrs branch
Lessons Learned

Dependency Resolution

One of the biggest challenges in packaging is mapping upstream dependencies to existing packages in the target ecosystem. For FreeBSD, this meant:
- Searching /usr/ports for existing Python packages
- Understanding the @${PY_FLAVOR} suffix for Python version flexibility
- Discovering hidden dependencies (like chevron) that weren’t immediately obvious from the package metadata
Build System Quirks

Python packaging has evolved significantly, with projects using various combinations of:
- setup.py with setuptools
- pyproject.toml with various backends (setuptools, flit, hatch, poetry)
- Legacy setup_requires patterns that don’t translate well to system packaging
Creating patches to work around these issues is a normal part of the porting process.

Testing Across Platforms

Running a FreeBSD VM (via VirtualBox) proved essential for testing ports before submission. The build process can reveal missing dependencies, incorrect paths, and other issues that only appear in the actual target environment.

Summary

Package Version AUR FreeBSD
python-fsrs / py-fsrs 6.3.0 ✅ Published 📝 Submitted
python-genanki / py-genanki 0.13.1 ✅ Published 📝 Submitted
python-ankipandas 0.3.15 ✅ Published 🔜 Planned

Get Involved

If you use these tools on Arch Linux or FreeBSD, I’d love to hear your feedback. And if you’re interested in contributing to open-source packaging:
- AUR: Browse orphaned packages and consider adopting one you use
- FreeBSD: Run pkg query -e %m=ports@FreeBSD.org %o to find unmaintained ports you have installed
Every package maintained is one less barrier to entry for users who want to use great software without fighting with dependency management.

Published: January 2026

Repository: github.com/chrislongros/freebsd-ports
GCC 15.1

May 2nd, 2025

https://gcc.gnu.org/gcc-15/changes.html
:(

February 15th, 2025
The FreeBSD Gods

January 14th, 2025

bsdimp is by far the most prolific FreeBSD contributor with just over 10k commits. His first commit was on 1996-09-22 on the 2.2.0 RELEASE.

https://github.com/freebsd/freebsd-src/graphs/contributors

Package	Version	AUR	FreeBSD
python-fsrs / py-fsrs	6.3.0	✅ Published	📝 Submitted
python-genanki / py-genanki	0.13.1	✅ Published	📝 Submitted
python-ankipandas	0.3.15	✅ Published	🔜 Planned

Tag: programming

Anki Sync Server Enhanced — Now Available as a TrueNAS App

Why Self-Host Your Anki Sync?

What’s Included

How It Works

TrueNAS Installation

Connecting Your Anki Client

Building It: Lessons from TrueNAS App Development

Get Involved

Ready to Self-Host Your Anki Sync?

r-fsrs: R bindings for the FSRS algorithm

What is FSRS?

The Rating Scale

Why Rust + R?

Architecture

Usage Examples

Getting Started

Tracking Memory Decay

Use Cases for R

Building Rust + R Packages

Resources

What’s Next

Contributing to Open Source: Creating Packages for FreeBSD and Arch Linux

The Motivation

Arch Linux User Repository (AUR)

python-fsrs 6.3.0

python-genanki 0.13.1

python-ankipandas 0.3.15

FreeBSD Ports Collection

py-genanki Port

py-fsrs Port

Lessons Learned

Dependency Resolution

Build System Quirks

Testing Across Platforms

Summary

Get Involved

GCC 15.1

:(

The FreeBSD Gods