“Never let your readers hear the dice roll.”

It’s common advice from genre writers at gaming conventions, and it’s good advice.

It’s not a prohibition from using the framework or scaffolding of a game system — Honor Among Thieves uses initiative order and D&D’s time pacing during its combat scenes. It’s done well and feels natural even if you’ve never heard of the game before. While that stands out to D&D players, that scaffolding is not obvious, even though it is present.

The principle applies more broadly; when the scaffolding shows, the story suffers.

Plot stupidity, deus ex machinas, anything where it leads the reader (or viewer) to suddenly realize that the only reason certain things are happening is “because there has to be a plot.” (The variant “Only the Author Can Save Them Now” is definitely what I mean here.)

I’m only three episodes into season two of Monarch: Legacy of Monsters, and it seems determined to strip away the facade and show off that scaffolding.

Don’t get me wrong. I really enjoyed the first season of Monarch: Legacy of Monsters; it was nuanced, layered, and smart. While characters made occasional stupid choices, it made sense within the context of the story and the nature of that character. The hotheaded military guy is aggressive when that’s not a smart move? Makes sense. The idealistic person is blindsided by humans being awful? That tracks. The burned-by-the-system cynical character doesn’t trust anyone enough to share information? Of course not.

In season two, a world where Godzilla is known to exist, Monarch is still ill-funded and ineffectual. A few real examples from the same episode: It absolutely makes sense that corporations would try to profit from Titans (thank you Pacific Rim), but a third of a way through the second season seems like a strange place for a group you’ve never heard of before suddenly be ultra-influential and an outsized factor. Ah, there’s giant billboards showing some of your party’s faces as wanted fugitives? Let’s have them go run a simple errand instead of laying low, I’m sure it’ll be fine. Oh, you just happen to have an old “prototype” of the exact doohickey we need? How convenient.

Of course we all know that, yes, it IS convenient for the authors and writers. Those things drive the plot. You need scaffolding to give the story structure and shape. But when those convenient coincidences (or lapses in judgment or memory) are too large or too common, your readers and viewers are having to mentally duck and weave around that scaffolding to follow the story.

They are paying more attention to the structure than to the story itself.

There are outliers — House of Leaves immediately comes to mind — where the structure is very obvious, but rather than detracting from the experience, helps draw one into it. I found Choose-Your-Own-Adventure stories compelling, not because I just wanted to “win” and get the best ending, but seeing how the story changed with those decisions. Even my pet peeve of “clap for Tinkerbell” — in the stage versions, at least — increases the immersion for the young audience it’s meant for.

If you’re thinking about your work in progress, TTRPG campaign, or what you’ll write in the future, there is a fairly easy solution. You know what decision you want the characters to make. You know where the next scenario or scene should happen. You know they’ve got to survive this unsurvivable fight somehow.

All you have to do is to rationalize it. And if you can’t rationalize it right away, add small details until you can.

One more actual example from the same episode of Monarch: Legacy of Monsters:

Our protagonists are being pursued by primitive religious zealots at night. It is a poorly lit night, and in some kind of wilderness, so everyone is just fast-walking. The zealots, who are maybe 100-200 meters back, want the protagonist’s camera, but are probably going to kill our protagonists as well. Ah, take the film out of the camera! That way we can keep the film and … leave the camera on the ground which may “buy them some time”. Immediate hard cut to one of the zealots walking carefully and examining the ground…and the camera pans down to show us our protagonists crouched in a small depression only 4 meters away.

Obviously they wanted this tense, life-in-danger scene. Across three different “will they be revealed” moments it both tense and provides a character moment for one of the zealots as well.

But to get to this scene, our protagonists had to wait for the zealots to catch up. They had to just…twiddle their thumbs instead of using the time the camera supposedly bought.

It would be easy to fix.

The ditch might be the only place to hide they could get to. One of them could have the classic “twisted ankle”. They argue too long about whether or not to give up the camera. Then they have a reason to be in the situation they’re in.

The same story beats can happen. The same scenes.

It just takes a little more effort and thoughtfulness.

This may seem like a small, unimportant quibble, and to a degree it is. We’re all aware there has to be some degree of scaffolding. There will be small imperfections here and there.

It’s what I said above, though. All those examples above are from a single episode. Even if any of them wasn’t big enough to kick me out of the story completely, having it happen over and over again was just too much.

You want the ways you get the story from one scene to another, or get your characters from one location to another, to at least try to make sense within the fictional universe.

It shows that you care enough about the story to make sure the scaffolding doesn’t show.

(1) Yes, I know there are some times that is acceptable or expected, work with me here.

Featured Image by Bruno from Pixabay

I got an infection in both ears this week.

It was pretty sudden; over the course of twelve hours I went from feeling a little under-the-weather to sitting in a retail chain’s clinic with both eardrums having at least a small rupture and serous (like from a blister) drainage from each of them (1), occasional dizziness, and a prescription for antibiotics.

I spent the next 36 hours pretty much in bed, and I’m still recovering as I write this. While I don’t feel as unwell as I did a few days ago, I’m still very aware that my hearing has taken a (hopefully temporary) hit.

This isn’t the first time I’ve had an eardrum blow from an infection; the prior time was just before the pandemic, but I’m still a little freaked out about the (again, hopefully temporary) loss of hearing in both ears. My hearing isn’t the best to begin with, and once you add in sensory processing issues, it was already a bit of a problem at times.

It’s not the watery “muffled” effect so often used to illustrate hearing loss; it’s mostly just like someone turned the volume knob down. But how bad is it, really? (If, fingers crossed, temporarily.)

I have a good set of over-ear headphones, so I slapped those on and headed to this open-source online hearing test with its handy-dandy online demo. (An offline tool that provides similar functionality for linux is here: https://gitlab.com/kreezxil/Linux-hearing-screen-toolkit .)

A short while later, I had this terrifying chart and a downloadable CSV file showing how badly the upper bounds of my hearing are degraded. I couldn’t hear the 8000 Hz tone at all, even though I could hear the audio channels click on to produce it! Luckily, most of the damage is above where speech typically happens, but that’s still… not great. Especially with a job hunt underway, I kind of need my ears at the moment.

Luckily for me, a lot of that can be funneled through technology — VOIP, video chats, and so on. Which means I have a chance to mess with the audio beforehand.

I used EasyEffects so that it was across my whole system and not just a single application. Using just the equalizer, I got it about right, then verified that I was on the right path (and accepted some suggested tweaks from) an LLM. I ended up with this equalizer setting; the main differences the LLM suggested were starting by turning everything down so I had more room to amplify without clipping and turning the very high frequencies back down to avoid too much hiss.

It also suggested adding some tweaks with multiband compression that I quite honestly don’t understand (“applying compression only to the upper bands to mimic hearing aid compression curves”?) but provide a small, but audible difference in quality for me.

Regardless, even without the LLM-suggested tweaks, having a system-wide user interface like EasyEffects made it pretty easy to adjust things so that everything sounds quite a bit clearer than it did before. I understand there’s even a way to build this directly into PipeWire without the nice user interface which will reduce latency, but since this will (hopefully!) not be quite so bad in a week or two, I’m not going to make any permanent changes yet.

But with hearing loss being a major risk factor for developing dementia, once my hearing has stabilized and I either have a new position with medical coverage (or Medicaid re-approves me), I’ll be able to take this data to a real professional and see how else I can cyborg my hearing back into better functionality.

(1) Any benefit from turning down the auditory stimulation is THOROUGHLY offset by the utterly squicky sensation of fluid dribbling slowly from both ears… shudder

Featured Image by Viva la vida!!! Rosa Matilde Peppi from Pixabay

There is an important distinction between objecting to your content being used to train an AI/LLM, and for one to process your content. Blurring that distinction does nobody any favors.

What rights do you have to your posts on social media?

I started thinking about this due to a reaction some users on Mastodon had to a tool designed to summarize a user’s own home feed so you didn’t have to doomscroll to catch up.

The objections were specificially about how the summarizing was being done — by an LLM.

I’ve been thinking about this a lot since then.

Not about the tool itself, or whether or not it’s worthwhile. But the objections.

Because the only way Jan (or anyone else) can actually prevent that is by not posting publicly.

Before I go any further: I think there’s an important difference between “my publicly posted content cannot be used to train an LLM” and “my publicly posted content cannot be see or used by certain classes of programs, people or entities.”

First, the technical aspect: Even if those who object block Voss, that won’t achieve the goal if you have any public posts. That just means that when Voss uses the tool it won’t include those posts. But if someone else does, your public posts will be included.

That’s because they’re… well, public. Public posts (or public web pages) have to get sent to the receiving computer to be displayed. We’re running up against the same problem that DRM — digital rights management — has: In order to show the content, you have to send the content to the person getting it.

Because viewing digital content inherently means copying it, we have to briefly consider copyright for simply viewing a post. (I am not a copyright lawyer, this isn’t legal advice, I’m just a mostly-knowledgeable layperson, and I’m discussing from a US perspective.)

You automatically have copyright on anything you’ve written in the US; technically you are providing a license to display your content to the social media site. But what rights do others have in regard to what you wrote?

The closest real-world analogy we have is of public photography; if you’re in a public space and do not have a reasonable expectation of privacy, then taking a photo of what you see is a reasonable expectation. Posting publicly on a social media feed is our digital equivalent to being seen in public. Taking a photograph is equivalent to displaying the post on the end user’s system. Add to that the ToS and express “right to display” that’s included, and that part is handled.

At that point, the copyright test depends entirely on the output. While your social media posts are copyrighted, that means that someone cannot replicate it. Arguably, my screencapture of the toots above would fall under this rule (although fair use clearly applies here). While a copyright holder does have the right to prepare derivative works, unless you’re discussing a summary of just your social media posts (rather than an aggregate of a timeline), that’d be a hard thing to prove.

It’s worth noting that this tool we’re talking about is utilizing other providers on the back end — either Anthropic or Copilot. So the data is being sent to them; whether or not they are using that data to train the LLM on is subject to whatever their ToS is.

That’s an important distinction — most copyright claims against LLMs is because they are substantially reproducing the style or content of the works it was trained on. That’s why I think giving the rights to use your content to train an LLM should always be opt-in only.

In contrast, the summaries this tool produces look like this:

This looks nothing like a timeline feed, isn’t reproducing anyone’s original content or style, and is clearly transformative. (Although whether or not you should trust a summary by an LLM is a completely separate issue!)

Whatever rules we apply to this tool, we also have to apply to a tool that, say, creates alt text for images that do not have them… even if that tool is a human.

Those copyright tests have nothing to do with whether it is a human, program, or LLM creating that output.

So the actual objection (and demand) is not actually that there’s a summary of a social media feed. The objection is about an LLM doing it.

It’s the functional equivalent of “you can only read this post on Firefox, you’re not allowed to read it on Chrome.”

And that is entirely too close to the “shrink-wrap EULAs” for my comfort.

You know the type: “By receiving this email you agree to” and the like. Sort of like the anti-EULA that you’re now subject to because there’s a link to it in this post. They’re all bullshit, and particularly in cases like this, where it’s just one parties’ unwritten social expectation. I cannot say, for example, “all employees of this company cannot read or discuss my posts”in the posts and seriously expect that to hold water. (I’m sure you can imagine much more distasteful examples.)

Again, I think there’s an important difference between “train an LLM on my content” and “my publicly posted content cannot be see or used by certain classes of people or entities.” The first explicitly prepares the LLM to make derivative content. The second is functionally equivalent to viewing a post on your RSS reader, browser, or client.

There are real, valid concerns about AI/ML. Freaking out over an AI simply reading your public posts distracts from those real concerns.

Featured Image by Gerd Altmann from Pixabay

Watching over the air television in linux keeps getting easier. (1)

I had a USB tv tuner that I wanted to see if I could get to work with my laptop, particularly with the storms coming through. I figure that even if the power and internet were to go out, I could still watch weather updates from broadcast TV.

The last time I tried was several years ago, and it was a bit of a pain or required installing a whole framework, all of which was far more work and complexity that I wanted to deal with for something I’d use fairly rarely.

Well, it’s easier now. Starting with this guide, it’s even easier since w-scan is now packaged in Debian, and you can just use VLC. NOTE: The package name is w-scan but the program name is w_scan.

sudo apt install w-scan vlc

then from the commandline:

w_scan -ft -A3 -c US -L > ../vlcchans.xspf

That will take a while; in my region it took about ten minutes.

After that, it’s as simple as

vlc ../vlcchans.xspf

It’ll automatically start playing the first entry; to get back to the channel list, stop the playing channel.

(1) Though after watching some broadcast TV, I’m reminded why this was such a low priority for me.

Featured Image by Pikurā from Pixabay

TL;DR: Google patented a system that will silently swap out your page for an AI generated one if they want to. It is time to stop using Google search.

There are quite a few people who have been annoyed at Google’s AI summaries and promoted search results. To those people: You made the right choice.

If you’re still relying on tricks like adding a bit to the end of your search or an extension, this news from Forbes indicates that soon won’t be enough. (1)

A patent granted to Google on January 27, 2026 titled “AI-generated content page tailored to a specific user” describes a system that evaluates your company’s landing page in real time and, if it decides the page won’t perform well enough for a specific user, replaces it with an AI-generated version assembled on the fly. The user never sees what your team built, they see what Google’s machine learning model thinks they should see instead.

The system described is not just a summary on the search. The article says this system will invisibly change what the user sees instead of your site, changing what is presented in your browser.

That alternative page isn’t a cached copy of your site. It’s a dynamically assembled page built from the user’s current query, their search history, their account context, and whatever Google can extract from your original page. The patent describes possible elements including personalized headlines, suggested product filters, a product feed, sitelinks to product detail pages, and even an embedded AI chatbot. In other words, a complete brand experience built by Google. Not you.

This is terrifying. Even if you use a different search engine, Google is the “default” for so many people that it’s practically a common noun. This is a degree of change and control over what others see that nobody should have.

And you can stop it.

How?

Stop. Using. Google.

If you don’t like those AI summaries and don’t want it to get worse, you have to vote with your (virtual) feet. That’s it. Change the default search engine, everywhere you can, and stop using products that won’t.

This is something you can do that has real results, as we can see with Microsoft’s floundering from shoving Copilot into everything and users, en-masse, simply not using it. The company is changing what they are doing as a result.

The same has to happen here.

I personally use — and recommend — Kagi for search. It’s a paid service, but their argument for why it’s worth being paying for makes a lot of sense to me, and I’m very happy with the results. DuckDuckGo is frequently mentioned, as is Brave, but there are loads of search engines that respect your privacy, and if you want, you can use (or even self-host) SearXNG.

(1) The viewpoint from the Forbes article presumes this is a bygone conclusion, and focuses on how businesses can cooperate with this, and make the web less friendly for humans and more useful for AI.

If there’s one insight we all need to focus on most, it’s this: your job is no longer to build a destination. It’s to build a parts library. And one that’s well documented so that when an AI agent re-assembles those parts for the human on the other side, the parts are put together in a way you wish to be represented.

As a technical matter, this is simply bullshit. Delivering different content depending on the capabilities of the viewer has been around since MIME/Multipart email was first developed last century. Delivering sitemaps and mobile-optimized pages is a matter of course, and has been for years.

One of the biggest gaps when moving away from Discord — at least for me and my group — are some of the specific bots and services that can be used with our group calls.

I do NOT mean AI-powered chatbots. These are utility programs.

Specifically, there’s four things that we tend to use:

• A text chat bot for die rolling and simple reminders
• Audio streaming from an MP3 or OGG streaming station
• Using a local soundboard (the quite excellent Kenku-FM)
• Audio recording (we’ve been using Craig, which is currently Discord-specific)

With the exception of recording, there are not official ways to do this, and I was concerned that the processing demands of the official recording solution (Jibri) would exceed the hardware for the decade-old laptop I’m building all of this on.

I did find some scripts that had limited functionality, required adding a browser extension, or hadn’t gotten updates since before the pandemic, but found them not meeting the needs of this project in some fashion.

Using those as a base or inspiration, and with a non-trivial amount of help from an LLM (1), I developed and tested a solution for all of the above that works in your browser, without installing anything (2), and without being a huge change to your workflow (3).

ASIDE: A big caveat is that any of the audio functions effectively require you to use a self-hosted Jitsi Meet server due to the way that the public instance does shard load balancing. (4)

The quickstart? Go to the GitHub pages page for the project in a new tab https://uriel1998.github.io/jitsi-bot/. It will load all four bots into iFrames in that tab, where you can toggle them independently. Put your conference URL into the appropriate field, and click “Toggle Bot”. It’ll reload in that frame and connect; the field will change colors once it’s connected. You can also see a log if you scroll down inside the iFrame.

Don’t like the iFrame? Then load the bot you want separately:

https://uriel1998.github.io/jitsi-bot/streaming/streaming.html

https://uriel1998.github.io/jitsi-bot/soundboard/soundboard.html

https://uriel1998.github.io/jitsi-bot/chatbot/chatbot.html

https://uriel1998.github.io/jitsi-bot/recording/recording.html

The chatbot has quite a few commands; try !command to start. It includes a die roller, card shuffler and drawer, text tarot card draw, and being able to respond with text files. You can put your own text in (if you run the bots locally) to meet your needs.

The soundboard bot will accept any audio through the virtual microphone, so if you’d rather play your local music player through there instead of the streaming version, go for it!

The recording bot will record audio tracks per-speaker and as a single combined whole. It will save the audio in chunks as .webm files every few minutes, so when prompted, tell your browser to save that filetype automatically.

That is both to allow the script to run in a smaller memory space and to protect against data loss if something crashes. There’s a merge_recordings script in the repository for Linux, Windows, and Macs to automatically stitch them together with ffmpeg and clean it all up.

You can see the rest of these guides for moving away from Discord to NextCloud and Jitsi Meet on previous posts on my blog.

Featured Image by Alexandra_Koch from Pixabay

(1) Because I know this is contentious for some folx: I know enough to follow the structure, but I don’t know the specific syntax and commands to achieve specific goals. I also am not claiming any authorship or copyright on these scripts; any restrictions on their use is based off of the license of the code that was used for a base/inspiration. While functional, they are intended to be proof-of-concept. The idea is to maximize the public good against the use of the LLM to assist me in developing these.

(2) Okay, technically you need a virtual microphone for the soundboard bot and ffmpeg for merging recordings for the recording bot. Get a free virtual microphone without having to use OBS: Windows,Linux,Macs. Get ffmpeg : FFmpeg download page (Windows builds), FFmpeg download page (Linux packages), Homebrew ffmpeg formula

(3) I have touched base or put in issues with the dev team for both Craig and Kenku. Craig’s development team pointed me (ironically) to their Discord; I’ve not seen a response from Owlbear Studio. However, see #1 above; PLEASE use this proof of concept to do something better.

(4) If there’s a way around it without running a headless browser as a client, I cannot figure it out. If the Craig dev team, Owlbear, or any other coder want to focus on a value-add beyond these, PLEASE use this proof of concept to do something better.

If you just want to have video chat (and optionally a text chatbot helper), then using the public instance of Jitsi is easy to set up and has plenty of features. The big advantages of using the public instance of Jitsi are that it’s EXTREMELY simple, allows telephone call-ins, and that you don’t have to worry about total upstream bandwidth.

The downside is that because of the way the public instance does load balancing, that these simpler bots may (and probably will not) work on the public instance. On a public instance, adding in a separate audio stream for music or a soundboard or recording streams requires (effectively) running a whole other headless browser session for each stream.

It’s possible to use virtual microphones (or OBS) to mix in a soundboard or music stream on top of an existing speaker’s audio stream. However, OBS is not a lightweight application, and dumping extra audio into an existing speaker’s audio means that others cannot independently adjust it, problems with sound “ducking” from noise cancellation, and more.

My use case — audio-only calls and recordings for preservation and to use when writing recaps — happens to work well within the resource limits that I (and probably you) have. And because Jitsi Meet itself is just a forwarder, I can run it on the laptop already running NextCloud. Not only does this give us more control over everything, but it allows the usage of those lighter javascript bots.

Estimated time: Approximately 30-45 minutes, mostly cut-and-paste into configuration files. More if you need to install and configure a reverse proxy before beginning.

Before You Begin

Take a look at my bandwidth comparisons/estimates for audio and video egress for Jitsi and make sure your upload speed can handle the demands. This is the single most important consideration… unless you add on other optional services. Because of my bandwidth and how my group works, I’m restricting it to audio-only. If you want the default video options, I’ll tell you what NOT to change below as well.

Getting Started

Get A Separate Subdomain

The other big consideration is that you will need to be able to route traffic to the right place. You will need to obtain a separate subdomain name — the same process as you used for getting a DNS name from the NextCloud guide will work perfectly — regardless of which solution applies to you below.

I am going to presume for this that you already have a reverse proxy set up, but I will also show how to configure things if you do not use or want one.

Here’s an explainer about what a reverse proxy is, and a quickstart for nginx and caddy.

If you already have a reverse proxy

If you have a reverse proxy already in place, this is relatively trivial and I’m assuming you know how to add a forwarder to whatever you’re using. An example nginx config is available. Continue to “Setting up Jitsi Meet” below.

I don’t have a reverse proxy, and I now want one.

This is medium-difficulty, but is the cleanest and best way.

You’ll need to switch some things about your NextCloud AIO setup. From the Administration settings inside NextCloud, first click Open Nextcloud AIO Interface and then Stop Containers. Let that finish.

Open a terminal where your docker-compose.yaml file lives. If following my guide: cd $HOME/apps/nextcloud. Now stop and purge the mastercontainer (which will NOT delete your data):

sudo docker stop nextcloud-aio-mastercontainer  
sudo docker rm nextcloud-aio-mastercontainer

In your docker-compose.yaml file, open your editor and add these under environment::

      APACHE_PORT: 11000 
      APACHE_IP_BINDING: 0.0.0.0 
      APACHE_ADDITIONAL_NETWORK: ""

You can also optionally remove ONLY the entire lines under ports: that begin with:

- 80:80
- 8443:8443

Close your editor, and bring everything back up: sudo docker compose up -d

While all the containers spin back up, take that time to set up your reverse proxy to point at port 11000 for NextCloud. I personally use nginx, and there is an example config in my guide ready to have Let’s Encrypt run on it, as well as the example nginx config for Jitsi Meet here.

Continue to “Setting up Jitsi Meet” below.

I don’t have a reverse proxy, and I don’t want one.

This is the quick-and-dirty-but-it-is-running-NOW solution.

If you do not have a reverse proxy and do not want a reverse proxy, that can work by specifying a port for Jitsi to use. We are going to assume 8444 here. Separate guides may suggest using 8443, but that is already being used by NextCloud AIO. You will still need that separate subdomain.

Continue to “Setting up Jitsi Meet” below.

Setting Up Jitsi Meet With Docker

Because we already have Docker set up and running from setting up NextCloud, the official instructions work pretty much out of the box, although we’re going to tweak them and the order we do them in for clarity.

Back to the terminal! We are going to change to our user’s apps directory, create required directories, and download the program files for Jitsi Meet:

cd $HOME/apps
wget $(wget -q -O - https://api.github.com/repos/jitsi/docker-jitsi-meet/releases/latest | grep zip | cut -d\" -f4) -O latest_jitsi_meet.zip
unzip latest_jitsi_meet.zip
rm latest_jitsi_meet.zip
ls -d /*

The last shows you what directories exist here; there should be your nextcloud directory and one that begins with jitsi-docker-jitsi-meet, for example jitsi-docker-jitsi-meet-35879bb. Move into that directory: cd jitsi-docker-jitsi-meet-35879bb

We’ll create some mandatory directories:

mkdir -p ~/.jitsi-meet-cfg/{web,transcripts,prosody/config,prosody/prosody-plugins-custom,jicofo,jvb,jigasi,jibri}

We will also copy the example configuration: cp env.example .env

And then we will let a helper script generate some strong internal passwords for the .env file: ./gen-passwords.sh

Editing Jitsi Meet’s Configuration

Use your editor of choice to open .env. These are the entries to change, and why:

If using a reverse proxy

# If you are using a reverse proxy, alter these lines:
# We are going to use 8444 so the port forward instructions
# are the same
HTTP_PORT=8444
# Comment out this line with a hash mark like so:
# HTTPS_PORT=8443
# Your PUBLIC_URL line should NOT have the specified port
# at the end, like so:
PUBLIC_URL=https://meet.example.com
# Turn off Let's Encrypt certificate generation, HTTPs, etc. That is all handled
# by the proxy.
ENABLE_LETSENCRYPT=0
DISABLE_HTTPS=1
ENABLE_HTTP_REDIRECT=0

Continue to “Everybody Change these”

If NOT using a reverse proxy

# If you are NOT using a reverse proxy, 
# put a hash sign in front of the HTTP_PORT line.
# If Jitsi complains that it is commented out, 
# change it to something random you 
# are not going to use. 
# HTTP_PORT=8000
# Change HTTPS_PORT 8444
HTTPS_PORT=8444
# For the PUBLIC_URL line, 
# put your domain, but also make sure 
# it has the ${HTTPS_PORT} at the end.
PUBLIC_URL=https://meet.example.com:${HTTPS_PORT}
# Change these lines to enable Let's Encrypt, have HTTPS working, and 
ENABLE_LETSENCRYPT=1
DISABLE_HTTPS=0
ENABLE_HTTP_REDIRECT=0

Continue to “Everybody Change these”

Everybody change these

IMPORTANT : If your public IP address changes, for example, if your modem resets, you will need to change the public IP address in this file manually, then bring the containers down and rebuild them.
docker compose down && docker compose up -d --force-rebuild

We are going to fill in our public and LAN IP settings:

# Media IP addresses and ports to advertise by the JVB
# This setting deprecates DOCKER_HOST_ADDRESS, and supports a comma separated list of IPs
# PUT BOTH YOUR PUBLIC AND LAN IP ADDRESS HERE.
# JVB_ADVERTISE_IPS=74.111.11.111,192.168.1.5,
JVB_ADVERTISE_IPS=

We will use the TURN server from NextCloud AIO. The TURN_HOST is the domain of your NextCloud AIO instance, you get the TURN_CREDENTIALS from the Turn Server Secret in NextCloud Talk’s settings.

# Enable Turn
TURN_HOST=example.com
TURN_PORT=3478
TURN_TRANSPORT=udp,tcp
TURN_CREDENTIALS=biglongstringofstuff

Jitsi is set up to be open by default. Which I don’t have a problem with, except for that whole bandwidth thing… so we’re going to require authorization to create a room, but anybody can join an existing room as long as there’s an authorized user already in it.

# Enable authentication 
ENABLE_AUTH=1
# Enable guest access  
ENABLE_GUESTS=1
# Select authentication type: internal, jwt, ldap or matrix
AUTH_TYPE=internal

These are some changes to hide video user interface elements, since we are only doing voice calls. If that is not your use case, save the configuration file and skip to “Port Forwards.”

TOOLBAR_BUTTONS=microphone,hangup,chat,participants-pane,invite,profile
HIDE_PREMEETING_BUTTONS=camera,select-background,invite
ENABLE_LOBBY=0
ENABLE_PREJOIN_PAGE=1
ENABLE_WELCOME_PAGE=1

Save the configuration file.

We’re going to also define those same restrictions elsewhere for redundancy. I also put in a resolution restriction of 320px just in case someone still turned on their camera so it won’t immediately clobber the bandwidth. Create and edit the file ${HOME}/.jitsi-meet-cfg/web/custom-config.js and put this in it:

config.startAudioOnly = true;   
config.startWithVideoMuted = true;
config.resolution = 320;
config.toolbarButtons = [
    'microphone',
    'camera',
    'chat',
    'invite',              // invite button explicitly enabled
    'profile',
    'participants-pane',
    'hangup'
];

Save that file as well.

Port Forwards

This is going to be radically different depending on the make, model, and software your modem/router is using. Here’s an existing guide which covers many varieties.

You will need to forward port 10000/udp to the computer you’re installing Jitsi Meet on, regardless if you are using a reverse proxy. If you are using a reverse proxy, it will handle everything else.

If you are not using a reverse proxy, additionally forward port 8444 tcp/udp (or whatever port if you chose something different above).

Bring It Up And Secure It

Change back to the directory where your docker-compose.yml file is, and type docker compose pull && docker compose up -d && docker compose logs -f to let you see the logs. It should reach a steady state without errors; once it has, press Ctrl-C to get out of the logs.

I only created myself as an authorized user; you only need to have the people who are creating or moderating rooms to be authorized.

IMPORTANT: TheDesiredUsername should be JUST a username; for example, bob instead of bo*@*****le.com

The commands below will enter the loaded Docker container, create TheDesiredUsername with password TheDesiredPassword, then show you a list of all registered users, then exit. Do NOT change meet.jitsi in the block below.

docker compose exec prosody /bin/bash

prosodyctl --config /config/prosody.cfg.lua register TheDesiredUsername meet.jitsi TheDesiredPassword

find /config/data/meet%2ejitsi/accounts -type f -exec basename {} .dat \;

exit

You’re done! If you’re using a reverse proxy, you should see the Jitsi welcome screen if you go to just the URL. If you chose to not use a reverse proxy, you will always need to put the port at the end: https://meet.example.com:8444

You probably noticed that there are quite a few other features that you can enable here: a recording component, a transcribing component, a whiteboard, collaborative documents, and so on. I have not enabled them because we have them handled through NextCloud already or they put a non-trivial load on the system. Recording and transcription, especially if you are using video, will require much beefier hardware than the decade-old laptop everything else is running on.

Next I’ll do a full overview of the bots — including how to get per-speaker split recording — with your self-hosted Jitsi instance.

Featured Image by Alexandra_Koch from Pixabay

Text channels are still deeply important, and a major consideration when moving from Discord to another platform. Two major concerns are synchronizing the messages while you’re transitioning and exporting old messages from Discord and importing them into your new system (called “backfilling”).

It’s more than possible to achieve both easily with Discord, NextCloud Talk, and the help of a cross platform program called Matterbridge.

IMPORTANT: There is another program out there which is also called Matterbridge that works with some kind of home automation. You want the one at https://github.com/42wim/matterbridge

Matterbridge is a very versatile program that “bridges” chatroom messages from one service to another. It can do this for a lot of chat services, so just like NextCloud, there’s a lot of documentation, but it’s not always clear how it all fits together.

That’s why this exists.

How long this will take depends on how many channels you are bridging, and how many messages you’re backfilling; I would estimate somewhere between 30-60 minutes with this guide. Further, once you’ve set this up once, it keeps working and allows you to do some additional cool stuff.

Like my other guides on moving from Discord to NextCloud, it may seem like a lot, but I’ve done my best at making them all work as a “step-by-step HOWTO”.

IMPORTANT: You may be wondering why I didn’t use the Matterbridge integration from NextCloud. That’s because it immediately caused my instance to crash, so we’ll do it the (slightly) harder way.

You’ll need:

• Old Discord Server
• NextCloud server with Talk installed
• Python (a programming language for the importing of old messages)

Both Matterbridge and Python are crossplatform, but some of the specific commands may be slightly different on Windows or macOS. While there is plenty of documentation out there to cover various cases, the whole point of these guides are to get you up and running simply and quickly, so I am making the assumption that you followed my guide (or close enough to it), in which case you’re already ready, or that you have a linux host available for you to use.

Create The Bot Accounts

In NextCloud, click the circle in the top right and choose “Accounts”. Create a brand new account, and copy down its username and password in your password manager. Optionally, log in as the bot account to set its user icon and description to clearly note that it is a bot.

Setting up the Discord side is a little more difficult, but Matterbridge already has a really good step-by-step instruction for this part. DO enable webhooks. Copy the bot’s token (the very last step) to your password manager or notes; we’ll come back to it in a bit. Make sure this bot can access all the text channels you want it to.

Prepare The Text Channels

In NextCloud Talk, make a new and empty Talk channel for every text channel you wish to bridge and backfill from Discord. This is both so that it doesn’t flood Discord with old messages and so that ongoing discussions in that channel are not pushed back by our backfill from Discord. It does not have to be the same name, but it will make your life easier. Be sure to give the bot account access to every channel you want it to bridge, or you will get errors later.

For each channel you wish to bridge:

• Open the room and copy the end of the URL. This is the “token” for the channel. For example, it’s “thisparthere” for https://mycloud.example.com/call/thisparthere.
• Go to Discord, right click on the channel, and copy the Channel ID at the bottom.
  

I ended up writing it down like this, the important part is copying it.

#general,12345678910,abcdefg
#gaming-memes,2345678910,bcdefga

Download Matterbridge And Create The Configuration

• Open a terminal window on your NextCloud machine (or other linux host) and create a directory for Matterbridge to live in: mkdir -p $HOME/apps/matterbridge && cd $HOME/apps/matterbridge
• Download Matterbridge into that directory. The most recent releases live on GitHub, but as it’s been three years since one, you can (currently) just do this: wget https://github.com/42wim/matterbridge/releases/download/v1.26.0/matterbridge-1.26.0-linux-64bit
  • If you are NOT following my guide, select the correct release on GitHub for this step.
• Download my example configuration and make a copy with these commands (paste on one line):
  wget https://gist.github.com/uriel1998/f5c824c5a028b323786387968b6559f2/raw/95f9090ad554870cb9704376d6101cde820545da/matterbridge.example.toml && cp ./matterbridge.example.toml ./matterbridge.toml
• You’ll now need to edit this file. You can either use an editor in the terminal, or simply type xdg-open ./matterbridge.toml which should open the file in a graphical editor.
• Here’s what you need to edit:
  • Under [discord.mydiscord] add the Discord server and bot token
  • Under [nctalk.cloud] put your server’s URL, as well as the NextCloud bot account’s username and password
  • Skip down to the first [[gateway]] section. Each channel that you are bridging has its own gateway section. Each of these sections starts with the line [[gateway]]
  • For each [[gateway]] section, put the name you want to call that gateway, fill in the Talk channel token, and the Discord channel ID. There are two examples already in there, just keep repeating [[gateway]] sections for each channel you want to bridge.
• Save the file.

Test And Set It To Automatically Run

• In the terminal, type matterbridge-1.26.0-linux-64bit. This is where you find out that you made typos and can check that it has access to everything. If there are no errors, type Ctrl-C to stop it.
• To get it to start automatically.
  • If you are NOT using my guide, you might want to look at the official instructions
  • Download my example configuration file from here by typing in the terminal (on one line):
    wget https://gist.githubusercontent.com/uriel1998/07591f2ca9ec123658c33c36dcbdba52/raw/47caba7dcead74c25461a1e28854529e5143e7c9/matterbridge.service
  • Edit this file just as you did the example earlier. The only thing you need to change is to put your linux username where it says USERNAME (twice), and save the file.
    • If you put matterbridge somewhere else, change the whole path name to point to the right location.
  • Type sudo cp ./matterbridge.service /etc/systemd/system/matterbridge.service
    • You’ll need to put in your password for sudo commands; that’s administrator access
  • Type sudo systemctl enable --now matterbridge.service
    • This will not only add it to start when the computer boots, but it’ll start right now as well.

Import (Backfill) Old Messages From Discord

As I mentioned above, Matterbridge will automatically backfill from NextCloud to Discord, which is the opposite of what we want. But since we’ve already configured Matterbridge with all the information we need, we can use a python script I put together to pull old messages out of Discord.

IMPORTANT: The script does not check if it has already imported a message. If you run it more than once, you’ll get duplicates. Use --dry run to test it first!

• Still in the terminal, type cd ~/apps to get to the main apps directory.
• Download and unzip the program, get rid of the zip file, and change to the right directory: wget https://github.com/uriel1998/discord_talk_backfill/archive/refs/heads/master.zip && unzip ./master.zip && rm ./master.zip && cd discord_talk_backfill
• Copy your Matterbridge configuration into this directory: cp ../matterbridge/matterbridge.toml ./matterbridge.toml
• Check the script and have it auto-configure by typing python3 ./discord_talk_backfill.py --help. You should see something like the help block below.

IMPORTANT: When the script runs, it is going to do a bunch of things. It’s creating its own workspace (venv) to do things in and downloading the things it needs, but keeping them separate from the rest of your system. If this fails, try sudo apt install python3-venv and retry.

usage: discord_to_talk_backfill.py [-h] [--list-functions] [--dryrun]
                                   [--maxmessages MAXMESSAGES]
                                   [--daysback DAYSBACK]

Backfill Discord messages to Nextcloud Talk using matterbridge mappings.

options:
  -h, --help            show this help message and exit
  --list-functions      List script utilities and exit.
  --dryrun              Print transformed payloads without posting to
                        Nextcloud Talk.
  --maxmessages MAXMESSAGES
                        Maximum number of most-recent messages to read per
                        Discord channel.
  --daysback DAYSBACK   Exclude messages older than this many days.

• Type python3 ./discord_talk_backfill.py --dryrun and make sure there are no errors and that you have channel pairs set up correctly.
• Type python3 ./discord_talk_backfill.py. For most use cases, you will not need to use any options.
• Watch the messages appear in your Talk channel. It will post 25 at a time, so it may take a little while.
• The script adds 🪏 to the messages to indicate that they’re backfilled.

The one “gotcha” is that because of the way that images and attachments are handled in Discord, they may just show up as links in NextCloud in backfilled and bridged messages. The links work, they’re just not inline if they link to something on Discord’s servers.

And you’re done. Your text channels in NextCloud have pretty much the same content as your Discord channels. As your group/team/players transition to using NextCloud, they may post in Discord instead by accident; this means their messages aren’t lost.

Additional Cool Stuff

As mentioned, Matterbridge is a very versatile program that can bridge between quite a few chatroom types, including Mattermost, Microsoft Teams, Mumble, Slack, Telegram, WhatsApp, XMPP, Matrix, and even (with some extra work) MINECRAFT.

In order to do that, you configure the service at the top, and then add that to the [[gateway]] section. For example, if I’d configured a XMPP (Jabber) at the top as well, and wanted to have the general chat channel show up both in NextCloud and on my Jabber server, I’d add the last three lines:

[[gateway]]
name="general"
enable=true
[[gateway.inout]]
account="nctalk.cloud"
channel="nextcloud_talk_room_token"
[[gateway.inout]]
account="discord.mydiscord"
channel="ID:123456789012345678"
[[gateway.inout]]
account="xmpp.myxmpp"
channel="general"

Featured Image by Tumisu from Pixabay

I think that NextCloud + Jitsi Meet replicates nearly everything Discord does, but self-hosted and without the privacy and ongoing enshittification. Enough so that I wrote a step-by-step guide on how to do it with a 10-year-old PC, and an add-on about adding a layer of security in only six clicks.

I recommended using Jitsi Meet over NextCloud Talk for audio/video conference rooms, and the lack of bots to handle some functions that are possible in Discord. I’m going to explain why I made that decision, some of the considerations that went into that recommendation, what you need to consider when choosing whether to use the public Jitsi Meet instance or self-hosting it, and what I did to make it all work anyway (as well as the bot situation).

TL;DR: Use Talk for the equivalent of text channels on Discord, use self-hosted Jitsi (either audio-only or limiting video, depending on your bandwidth) for conference rooms. Proof-of-concept bots now exist (and work) that run in a browser window that, with a virtual microphone, allow audio streaming and recording.

This is the post explaining why I’ve made the decisions I have, so you can see if they work for you. Later this week I’ll detail exactly how to get it set up for yourself and your group (including the bots).

Integration And Security

NextCloud Talk is tightly integrated with the rest of NextCloud, which allows you to do all sorts of neat things with it. Embed files, control access by user groups, automatically create meeting rooms with appointments, and more. This is very neat, and I find it really useful with the text chat portion of Talk. Jitsi is designed to be open first, which is not ideal for self-hosted situations. It’s easy to add a lobby or password to an existing room, but neither is the default on the selfhosted setup. While making a room is super simple and easy, the default setup is to allow anybody who can reach the service to fully use it. Luckily for our use case, it’s possible to set up only a few users who are allowed to make rooms while still allowing anyone to join. You want this because of the next issue…

Bandwidth

I was surprised to find that just videoconferencing’s big demand was not CPU power or RAM; it’s bandwidth.

Both NextCloud Talk (with its “high performance backend” enabled) and Jitsi Meet serve as stream forwarders. If you only have two people in the call, it’s pretty straightforward – there’s a stream in and out for each participant. Two streams in, two streams out. (This is a simplification, but gets the point across.)

It’s when you start adding others that it gets problematic. Let’s say you have five people in the call and everyone’s video and mics are disabled. The server only has one stream coming in, but it has four copies of that stream going back out — twice as much as two people chatting.

And that’s with restricting everyone else. If you have two people with incoming streams, it gets even worse: two streams in, eight out. That number starts getting a LOT higher the more people you add to the call.

This means that as a practical matter, if you are doing video with your conference calls, you need to have not just good incoming bandwidth, but outgoing as well. Jitsi recommends:

For a friends/small organization server, 1 Gbits/s will often be enough but for a serious server 10 Gbits/s is advisable.

As of June 2024, only 70% of US customers had less than 500Mbps upstream (or half that speed). That is a serious problem if you want to use something selfhosted for more than 1-1 chats, regardless of whether you use Talk or Jitsi.

Jitsi has some ways to minimize the bandwidth by limiting the resolution of the video stream, limiting how many people are visible at any given time, or even turning off video entirely. If NextCloud Talk has similar controls, I’ve not yet found them yet. That’s a big point in Jitsi’s favor for me for group conference calls.

Recording Support

Both Jitsi Meet and NextCloud Talk have “native” ways to record conferences through adding on other services, through Jibri and Talked, respectively. Both work essentially in the same way: they run another copy of a web browser that connects to the call just like a human would, and uses that to get the audio and video.

This part does take additional CPU and RAM power — to the point that both recommend running the recording service on another system than the one handling the call. If you need video recording (or sophisticated audio recording, like per-channel streams), this is where you’re going to end up looking. The added complexity and hardware demand is more than I’m aiming for with my guide, or that my group needs since we do audio-only calls anyway.

But if you just want basic audio of everyone who is on the call, keep reading.

Bot Support

I was looking for two types of bots: one type that interacted through the text chat, and one type that deals with audio streams, such as mixing in music, sound effects, or recording the audio.

The bot ecosystem around both Talk and Jitsi is pretty sparse. I also discovered some severe limitations on both sides. To access the audio or video for Talk’s conference rooms, it seems like you essentially have to run a headless browser. Once again, that adds complexity and hardware demands that I want to avoid. However, Jitsi’s public instance, because of the way that it handles traffic, means that the audio bots that I found can’t stay connected… and I wasn’t able to find a way around that. They do, however, work just fine when it’s self-hosted.

Making It Work Anyway

Rather than force either bit of software to do something it doesn’t want, I leaned into the strengths and weaknesses of each. I’m using NextCloud Talk as the equivalent of the text channels on Discord. It’s well suited for that due to its integration with the rest of NextCloud. Also, since we can have bot access to the text channel, existing bots and existing integrations can be upgraded to provide the functions I need, like responding with customizable information or a customizable stickerpicker.

Because just running the conference room is not a big load on the computer itself, I installed it through Docker as well. I only had to create an account for myself, since I’m the only one who should be creating rooms. The configuration limits it to audio calls as well. I thought about limiting the number of video streams forwarded or limiting resolution, both of which Jitsi can do, but even then it would be a lot of bandwidth.

Limiting to audio means that with my table it’s estimated to average around 2.5Mbps upstream, well within my upstream bandwidth. But add 320p video and that more than doubles to an average of 5.5Mbps, and a maximum that exceeds my upstream. 720p resolution or better has even higher bandwidth requirements for the server, even if you’re limiting the number of outbound video streams. (Graphs of estimated upstream bandwidth for audio versus video resolution without any limiting are at the end of the post to give you an idea of what you might need for what you want to do.)

Luckily for me, my table does audio-only already, so that is more than sufficient for us.

By self-hosting the Jitsi server, that also means that I can use the bots I adapted to pipe in a http audio stream, connect a virtual microphone (so I can use Kenku), have the same chatbot functionality as in Talk, and record the audio stream to my local computer in a single extra browser window.

I’ll have a detailed guide later this week, but if this (plus the links in this post) is enough for you, give it a shot!

Featured Image by Alexandra_Koch from Pixabay

Dan Savage (among others) has pointed out that before trying to be in a relationship, one should be in “good working order”. While that is something pretty easy to assess at the extreme ends (like this commenter does), the reality of the situation is, as Dan says, that we are all used cars. You do not expect a used car to be factory-mint-condition, but you do expect it to be operational.

Because realistically, the odds of making it to adulthood — let alone the part of adulthood I am in — without experiencing some kind of trauma are near-zero. Every one of our “used cars” has metaphorical dings in the finish or a figurative slight wobble in the steering. And that’s before you account for the stress of the rest of the world.

But to expand that metaphor just a little bit further, “good working order” is not the same for all conditions or vehicles.

What counts for “good working order” for a golf cart is different than for a NASCAR stock car. That goes the other way as well: a stock car is pretty awful at caddying golfers on the green. My little three-cylinder car (“Hamsters”) is great for both tooling around southwest Ohio and going further west onto the relatively flat plains. It has a lot more issues when I go east over the Appalachian mountains, though.

There are some factors — interfaith relationships, long distance, polyamory, to name a few — that change the “road conditions” of relationships. They aren’t “bad” or “good”, just that they’re different “driving conditions”.

For example, if there is a slight (metaphorical) “steering wobble” in your relationship, it’s probably going to become more noticeable if the relationship becomes long distance.

Sometimes that means that you don’t take the relationship down that particular “road”. Perhaps you choose to not become long distance, or choose to break up. Sometimes that means that you instead do more work — sometimes a LOT more work — on the vehicle to get rid of that wobble. Sometimes you just adjust to it, especially if those “road conditions” are expected to change.

It’s more important than ever to keep that in mind these days. Not only does everyone have the “regular” amount of trauma, but the additional traumas of … well, the world since 2020.

It isn’t just whether or not you are in good working order, but whether you’re in good working order for the driving conditions of your current relationship(s).

And if you aren’t, what are you willing or able to do about that?

Featured Image by trendoss from Pixabay

My initial guide about setting up NextCloud as a Discord alternative was focused on getting you running quickly within 90 minutes. There’s quite a few tweaks and improvements you can make after installation, including making your setup a bit more secure.

There’s a really easy, quick way to make your server more secure: Add fail2ban. It’s a program that is designed to stop brute-force attacks against your server.

It’s a powerful program, with many many ways to configure it, to meet many use cases and possible issues. However, the NextCloud AIO team have put together a simple community container that makes it a few-click install.

• Go to the Admin settings of your NextCloud instance, and open the AIO interface.
• Click “stop containers” and wait for it to finish.
• Scroll down to “Community Containers”. You may have to expand the category to see the options.
• Select fail2ban.
• Scroll back up and “start containers”
• Aaaaand you’re done.

This will almost certainly work out of the box. For sure if you followed my guide, but even if you didn’t, it’s a very easy install and well worth it for the added security. In the tiny chance you get an error about non-matching iptables, it’s both known and solveable.

Featured Image by Vicki Hamilton from Pixabay

It’s a sadly familiar story: You or your group starts using a service, particularly because its free tier is worthwhile. But then the ads get worse. Or it becomes harder to keep your community safe from toxic actors, and moderation becomes overwhelming. Or you’re worried the platform may suddenly decide your account is in violation for something you didn’t do. Or you want to make sure your data is safe. Or the service itself gets worse, premium features become more expensive, or the service gets more invasive about your privacy and careless about your data. Or any combination of the above.

I’m facing the same problem; I run online tabletop roleplaying games and have relied on a Discord server.

With the controversies around Discord’s pending ID requirements roiling and corporate social media platforms promoting toxicity by design, there are a lot of people — including me — who are looking for alternatives. So I went looking.

And I found one.

It works, I set it up personally, and I wrote up a step-by-step guide to get you up and running using an old PC and about an hour and a half.

I’m going to tell you who this solution is for (and who it isn’t for), why I prefer it to the other solutions, what that solution is, and the remaining big catch (and why it’s not going to be a big catch for long). If you’re comfortable taking it from there, great. If that seems intimidating or confusing, then the few bucks for my step-by-step guide may be worth it for you.

Who This Is For

Before I go on, let me mention that my solution will work for many people and groups, but definitely not for others. This recommendation is for smallish groups. Roleplayers, gamers, small community organizations, and non-profits. Your church group or book club. Anything where you have a group of known (or at least invited) people.

If you are using Discord as a support forum, or have your server open to random people via invite, this is not what you want to be using. Arguably, you shouldn’t be using Discord for those purposes or your primary

It assumes the primary method of communication most times is going to be text with room-style video or audio chats intermittently. That there are files — notes, maps, handouts — that need to be shared with people, and perhaps worked on collaboratively. And it assumes that at least the person who will be in charge of it is familiar and not intimidated by computers. You don’t need to be a tech guru to benefit from my guide (although gurus may also find it useful.)

The Other Solutions Have Problems

While many are discussing TeamSpeak, Mumble, and others, those ideas suffer from one or more of a few problems:

• They want to swap one platform wholesale to another one. This just delays the problem by resetting the clock. The same forces that are driving Discord are going to drive any other for-profit business.
• They have the same or similar privacy concerns.
• The alternatives are lacking significant features. Discord has a wide feature set, and there really isn’t any one single product that is ready for production use that hits all the marks.
• The alternatives require a good deal of know-how to set up, both for the people running it as well as the users.

These are all deal-breakers for me. Your use case may be different, and a different solution might work well for you.

I found a combination solution that I believe is hands-down the best for hobbyists and small organizations, particularly with a few tweaks to smooth out some rough edges. It will allow you to not only leverage the strengths of the program itself, but also any other site you like if you want to use something different.

And with my guide and a ten-year-old laptop (or other older/retired computer), you can have something up and running in about an hour and a half.

The Solution

In a nutshell, the answer is NextCloud + (optionally) Jitsi Meet.

Particularly with its recent release, NextCloud handles nearly all of the features that Discord does.

Nextcloud’s business/academic bent means that there are a lot of integrated apps, and they’re all optional. Log in with your social media account. A cookbook. A kanban deck. Forms. Email, photos, and the like. It does have a Talk app with both text and video conferencing as well.

However, adding voice and video chat can add a lot of complexity, bandwidth, and processing requirements, so in order to get up and running quickly, the (free) public-facing instance of Jitsi Meet can help make that problem go away. With the public instance, participants only need a web browser or even just a phone. The person creating the meeting chooses a room name, and you’ll be able to share a link or phone number that will allow anybody to join (with optional password) for free, untimed video conferencing and zero setup.

And because both are open-source projects that have ongoing support — NextCloud, Jitsi — they don’t have the same incentives toward enshittification.

My goals for this project were to create a setup that has the features of Discord that I primarily use with online gaming, which also mirror those for small-group organizing. With the selection of apps and tech that I’ve outlined here, it fits that need well, and is also relatively easy to deploy quickly. You’ll spend way more time customizing and tweaking.

Just some of the benefits I’ve found:

• Can run entirely in a browser, meaning that my players don’t have to install anything.
• There are mobile and desktop apps for those that prefer such that as well
• Easily synchronize files, including from Obsidian, using a dedicated app in my system tray or using WebDAV.
• Share links to files and wiki pages to the public web, just to certain users, or not at all.
• My players can subscribe to a calendar with whatever they’re already using and see upcoming dates and times for sessions.
• Share folders of bookmarks easily to different groups, such as direct links to the campaign on Roll20 and D&D Beyond.
• Each user can have their own file space on the server.
• Collaboration on session notes and wiki built right in.
• Set up open office hours as a GM.
• Embed (almost) any site.

Because the data is integrated across all of the apps — while not being locked in to them — it means that I can create a board in Deck (the kanban app) so our party can plan how to best defend against the BBEG next week. Edit a page in Collectives (the wiki app) in a plain text editor on my laptop and have it synchronize. Get a notification on my phone if a player asks me a question.

The Catch

The one major catch at this point is the lack of a bot ecosystem (for either NextCloud Talk or Jitsi Meet) like the one Discord has for voice/video chats. While some exist, they are designed for corporate users, and so omit functionality that I need and seem complicated to install and use. I’ve already sent messages to the devs (or put a feature request in the issue tracker) for the two bots I mostly use: Craig and Kenku. There are not many more for text chat either, but that’s likely to change. I forked and modified one bot to include a few functions (rolling dice, drawing a card) for the text chat in Talk fairly easily. And between the first draft of writing that prior sentence and cleaning it up for publishing, I’ve been able to do proof-of-concept work to replicate the functionality of (or to wire in) both Kenku-FM and Craig, and running a few tests to see how viable this is using a self-hosted setup instead of a cloud provider. I hope to have a writeup of that at least a week before Discord changes their policies.

A Quick Shout-Out

I want to take the time to thank both of my gaming tables for helping me test and make sure this setup works and is viable for groups this size.

I also want to thank the people who have put in countless hours to develop this software and who have written all sorts of guides to various use cases. There is a lot of documentation that is out there, and I want to give them credit. At the same time… whew, it’s a lot of documentation. That’s great: if you find yourself in a weird situation, you’ll almost certainly find the answer. But jumping back and forth between documentation and determining what advanced settings are actually important for yourself can be really time consuming and exhausting.

Which is why my guide exists. This guide aims to make that part as easy as possible, and should get you set up and have something useable and running in approximately an hour to an hour and a half. My goal was to remove the (legitimate) complaint of “I don’t know how and the instructions are confusing”.

What Next?

If just knowing what I settled on is enough for you to take it from there, get to it! There is a lot of documentation out there for this software, but sorting through it, figuring out what was current and applicable, and so on, took a fair amount of time.

If you’d rather have a step-by-step guide on how to turn an old unused PC into a Discord replacement for a few bucks, then you want to check out my guide, which includes PDF, epub, and Kindle versions, along with a few configuration file examples.

I’m pretty happy with what I’ve put together so far. The biggest gaps for me are the bots I currently use for a soundboard/music and recording sessions. That said, I am nearly there with proof-of-concept models that either replace a service or, with a small tweak, allow you to use that service. While what I have now does work with Jitsi Meet, it’s not polished or fully ready for prime-time. My hope is that the guide and the proof-of-concept bots will be ready within a week. I also hope that with the additional attention and pressure to move away from enshittified corporate structures, the existing solutions — looking at you, Craig Team and Owlbear Studio — will incorporate them natively as well.

In the meantime, give it a shot. Pick up my guide if you want to save yourself some time and effort. If you don’t need the guide and found this useful, toss me a few bucks over on Ko-Fi.

And happy (private) computing!

Featured Image by Mohamed Hassan from Pixabay

John Oliver this week talks about what’s happened with Twitter since Musk took over, and as he says at the top of the piece, whatever you think you know… it’s worse.

One thing I did not know was that premium users can get a payout depending on retweets/likes/replies.

Not only is this bad, but it also highlights how the design of corporate social media encourages hate speech, misinformation, and bad actors. That’s not just bad for the platform and society at large, but also for legitimate people and businesses.

It deliberately incentivizes “engagement.” And the quickest way to get “engagement” is to try to piss people off. In its most mild form, it’s called Cunningham’s Law: “the best way to get the right answer on the internet is not to ask a question; it’s to post the wrong answer.” In its most extreme form, you’re talking about encouraging hate speech, which has most definitely increased on Twitter since Musk bought it.

Even a modest payout is a big deal if you live somewhere other than the US, and where the standard of living is lower. And some of these accounts claim to get payouts over $1K every two weeks, which is stretching the idea of “modest” by quite a bit.

Put those two elements together, and of course a bunch of people start deliberately rage-baiting everyone else on any topic that’s controversial enough. With that design choice, you are going to end up with a site full of anger, hatred, and prejudice. A site that actively works to make things more divisive. You don’t need a state actor running a botfarm (although they do). You don’t need the platform tweaking the algorithm (although they do, and have admitted doing it).

Just combining those two elements together provides a clear, strong financial incentive for the worst kind of posting on the site.

But it’s not just cash. While Musk made it explicit, there are definitely incentives that promote “engagement” on other corporate social media as well, highlighting posts that are “active” or “controversial”. Most people at least look at their engagement numbers, and intentionally or not, start playing to the audience to get “engagement”.

That’s natural, but when those posts are highlighted by the platform, by design the platform artificially increases the “virality” of those posts. (1) It intensifies the pressure to get “engagement” any way you can, even if it’s simply to be heard at all. That starts a self-reinforcing and self-perpetuating cycle and focusing solely on what to do to get more clicks/views/likes/shares. This is great for the companies running the social media sites, since that means more eyeballs and attention that they can then sell to advertisers. It’s not so great for everyone else. (2)

The result of this design choice is that arguments become more prominent than discussion. It predictably, inevitably, turns a town fair into a town brawl.

Not only is this bad for society, but this is bad for businesses of all sizes, from side-hustles and independent artists to Fortune 500 companies.

Because this design for corporate social media will bury your legitimate content under an avalance of rage-bait “popular” posts. Nobody has to be doing or manipulating anything, it’s built to work that way.

The result? If you want to be seen on corporate social media, you have to buy advertising from them, and hope their targeted advertising actually reaches the right people: both the people who already follow you, as well as those who are interested in you. Research suggests that their targeted advertising is not so targeted, so in order to get the results you expect, you buy more advertising to make sure it gets out there. Cha-ching.

There are solutions to this. One is voting with your feet, both as a business and as an individual. Or if you don’t leave those sites, limit your engagement on them, and be deliberate about what you engage with. For businesses, particularly those who buy advertising, make your displeasure known however you can. If it makes sense for you, try Bluesky or Mastodon or Pixelfed. Or even go back to having your own site and RSS feeds and newsletters and Patreon/Kofi/Medium, where your audience is the people who are interested in you or your product.

And the platforms could solve this problem as well. Ordering your feed in chronological order was the default not all that long ago.

And, of course, stop paying people for arguments. That was only funny when Monty Python did it.

(1) Look, everyone looks at their numbers, at least a little bit. It’s difficult when you feel like you’re screaming into the void. I’m saying here that the design of featuring posts with “engagement” artificially makes some things more “viral” than they would be organically. And by increasing that effect, it increases the pressure to just to get that “engagement” in order to be heard.

Featured Image by Ольга Фоломеева from Pixabay

When it comes to keeping your digital life secure, there’s one bit of advice that I’ve been recommending over and over again:

Have a password manager, and make it one where you control who holds the data.

That part after the comma is almost as important as the part in front. And knowing that can also save you some cash.

What is a password manager? There’s a lot of them — including the built in one that’s probably in your browser offering to auto-fill passwords — that offer all sorts of bells and whistles.

But really, all a password manager must be is a Notes app that encrypts its notes under a master password. (1) It’s like you have written all the passwords for everything else into one locking diary. (2)

You have the master password — the only key to open that diary — so you no longer have to remember all those other passwords for all those other sites. Just remember that one password, and you no longer have to worry about any of the others, no matter how long or complicated they are. As long as you remember your master password, you’re set. And if someone were to try to sneak a peek at that diary of your passwords, they can’t get in without the key.

Well, mostly.

Just like in our analogy, if someone physically had your locking diary, they could pick the lock with enough time and skill. And that brings us back to where we started: who holds the data.

One of the most needed features is being able to access those passwords wherever you are. Your computer (no matter what operating system), your phone, tablet, and so on.

But the “cloud” — and the services that synchronize over it — are just someone else’s computer, and open to being hacked themselves. After previous multiple breaches at LastPass or OneLogin, those hawking paid password manager solutions make a point of saying they still cannot read your data (although that seems to be not entirely accurate in all cases).

Even if they cannot, ultimately, what you are paying for with your subscription to these vendors is for a tiny bit of cloud storage service where hackers know there is a lot of juicy data being stored in the same place. (3)

For most people, I continue to recommend using the open-source, crossplatform, free, and feature-rich KeePassXC for storing their passwords on their computer. Use one of the many mobile apps that can read KeePass format (I use Keepass2Android Offline; Keepassium is for iOS and maintains a list comparing features with other iOS apps) to access your passwords on mobile phones and tablets.

And then use whatever syncing service you already use for everything else to keep them in sync. Yes, even if you’re using a commercial service like iCloud, Google Drive, or Dropbox, that still means your password diary is not being stored with a whole bunch of other password diaries.

You don’t have to. If you want to avoid that possibility, you’ll probably be interested in (free, open source, crossplatform) SyncThing, or if you have a home server, look into installing NextCloud.

And then stop paying someone else to keep your passwords in a big room labeled “everyone’s passwords.”

Featured Image by Mohamed Hassan from Pixabay

(1) Yes, you can use a Notes page that you lock behind a password if you must.

(2) That password diary is usually called a “vault” for the symbolism.
(3) This characterization of their services applies when talking about everyday individuals. Services for teams, organizations, and corporations are a totally different beast and quite a bit more complicated.

Have you gotten a DMCA takedown notice from “Citi Legal Services” about an image you have on your blog, Patreon, or website? Particularly if it’s an image that you originally sourced from Unsplash, Pixabay, or the like, and appropriately credited?

Yeah, it’s a scam.

I got an email yesterday with the subject line “DMCA Copyright Infringement Notice” notifying me about a picture I’d used on the blog from Unsplash. The email looked mostly legit (I have added (dot) to the domains so that they are not live links) :

Dear owner of https://ideatrash.net/2023/10/not-all-substances-are-the-same-bad-research-illustrates-how-the-conversation-needs-to-change.html,
​
We're reaching out on behalf of the Intellectual Property division of a notable entity, in relation to an image connected to our client Pill Reports.
​
Image Reference: https://i.imgur.com/3eWDnKx.png
Image Placement: https://ideatrash.net/2023/10/not-all-substances-are-the-same-bad-research-illustrates-how-the-conversation-needs-to-change.html
​
We've observed the display of the image on your site. We need you to add a credit to our client immediately. A visible and clickable link to https://pillreports(dot)net/ is required, placed either below the image or in the page's footer. This should be addressed in the next five business 
days.
​
We're sure you realize the urgency of this request. Kindly understand that simply removing the image does not conclude the matter. Should we not see appropriate action within the given timeframe, we nned to activate the case No. 64351 and take action as outlined in DMCA Section 512(c).
​
For your convenience, past usage records can be reviewed using the Wayback Machine at https://web.archive.org, a recognized digital archive.
​
Think of this as formal communication. We value your swift action and your cooperation.
​
Kindly communicate in English.
​
Rob Anderson
Trademark Attorney 
​
Citi Legal Services
1 Beacon St 12th floor
Boston, MA 02108
​
rob@cl-experts(dot)info
www.cl-experts(dot)info

The “notable entity” made me question whether or not it was a real DMCA notice, and doubly so when I looked at the page in question and saw that I had, indeed, appropriately credited the image, which was sourced from Unsplash. The website mentioned in the email (which is the same content as clexperts(dot)biz ) seems polished, but when I tried the contact phone numbers, the 800 number went nowhere and the other number went to a very puzzled answering service.

I’m a little confused as to the point of the scam — the website they wanted a link to is apparently about the drug ecstasy, and hasn’t posted anything for nine months or so — but I was quite annoyed at having to spend my time figuring this out.

I was annoyed enough that I bothered to look up the WHOIS information for those domains, and report them to the abuse departments for their domain name registrar and hosting company.

Geek Mamas (among others) has written an even more detailed look at this backlinking scam, which has been going on with the same fake company and boilerplate email for at least a year.

Stay alert and stay safe from the scammers out there.

Featured Photo by Markus Winkler on Unsplash