I have not been very communicative of late. My apologies for that! I am going to fix that with this lengthy write-up.
For months now, I have been emotionally and mentally challenged by the reorganization aka 'transformation' which started in my company in January of 2026 and will continue into the new year, causing loss of jobs and a lot of stress (in my group as well as myself). In order to keep myself busy and distracted from all the hubbub, I play around with fun technology.
What fun tech? Slackware, the distro, feels a bit distant for me these days. I just wished there would be a stable release but I don't control the pace and I've decided that I'll just wait and sit it out. There will be much-needed release at some point, and I have lots of servers that keep me busy (updating their '-current' installations all the time) where a stable release will bring peace of mind. My Slackware related activities mostly revolve around keeping Chromium buildable on the stale Slackware 15.0.
What I do instead to challenge myself with something new is to play around with AI. Yep.
I know the aversion that many people have against AI, its use, the way these LLM's are trained and the detrimental effect they have on parts of the world economy. But, as with the introduction of any new disruptive technology, this is a passing phase and the use of AI will rationalize like it did for the steam engine, the train, the car, the computer, and tamagotchi's.
AI can be used as an accelerator of development, as long as you remain in control of the workflow and the ideas start with you... and the quality control ends with you.
My fascination is with Claude AI, and intellectually I needed to see what the value of such a tool can be to Slackware.

In preparation for my upcoming retirement from work (with a gentle nudge from my current employer ASML) I have been sparring with Claude AI, defining the outlines of multiple small and bigger projects to keep myself busy. One of these projects was already trying to take shape in my head some some years. It answers my question: how to automate the deployment of collaborative web services onto a fresh Slackware server. Eh? Let me refresh your mind then.

In the weeks before the Slackware 15.0 release, already way back in January 2022, I started a blog article series which I called "Slackware Cloud Server". You can find that article series under an easy-to-remember URL https://cloudserver.slackware.nl/ which redirects to one of the pages on this very blog.

The idea behind the Slackware Cloud Server series is written down on its landing page:

This is an article series about using Slackware as your personal cloud platform, running collaborative web-based services on a server which you own and control.
Think of file-sharing, video-conferencing, collaborative document editing, decentralized social media, streaming video and audio, backing up your 2FA codes, syncing files from your desktop and your phone to your cloud server.
And all (or most) of these services are accessible via Single Sign-On: only one user account is needed to access the goodies on your private cloud platform.

The target audience I had in mind? Small communities, families, any group of people basically that has enough of the Big Tech lock-in where your data is no longer your own and being sold to the highest bidder.
I went to great lengths to test, install and then document the steps needed to setup such a server. It took an enormous amount of time to be honest. I have no idea if anyone ever was brave enough to follow the instructions and actually build such a Slackware Cloud :-) I myself put my articles into practice and built a demo server for the Slackware crew, https://tek.slackware.nl/ .

My project is unrelated by the way, to https://slackware.cloud/ which is an evident 'rip-off' of my ideas as outlined in the blog article series ;-) That project is nothing more than some Slackware branding slapped on top of a commercial 3rd-party offering which is not running on Slackware at all. Fine, but I do not want to be associated with it.

Since that Slackware Cloud Server article series, I could never find the time to actually create something that is more than documentation. I was thinking about creating a set of Slackware packages that would install Keycloak, Jitsi, Nextcloud for you - fully pre-configured and ready-to-go. That would be next-level!
Earlier this year I realized that with the use of Claude AI I should be able to accelerate the speed of development of such an ambitious project and finish with something more widely usable. I chose Python as the language for this project (and PyQT6 for the graphical programming), Slackware-current as the target OS, Docker containers to run all the applications; and I made list of all kinds of requirements that would make this a safe-to-deploy solution. I decided to call this project "slackcloud" which is a better name for a Git repository than "slackware-cloud-server".

Right now "slackcloud" is a private repository on the Slackware Forge, i.e. it is not accessible by anyone but me... but that will change in future when the code is stable.

To kick this off, I wrote the premise for the project as a "CLAUDE.md" file, and defined the specifications for my project (some of which I already mentioned higher up). Claude Chat translated these specifications into a design document "DESIGN.md". Claude Code reads these two files from a local git clone on my laptop every time when it starts, and uses it to write the actual code. Claude Chat owns the design and reviews the work that Claude Code delivers, then shares with me the decisions to make before the coding continues (usually to resolve ambiguity in the specifications and sometimes because my ideas are proven to not work in reality), and I test the results.
The project progresses in well-defined stages. That works surprisingly well, with Code and Chat communicating via a "PROGRESS.md" document and challenging each other's assumptions. Every stage results in new, sometimes unexpected findings which then are reconciled and folded into the design. This way of working has been evolving for a few months now, and it's leading to something which I would not have been able to achieve personally in my lifetime. Great care is taken (through my explicit instructions to the AI) to log and document everything that slackcloud does and creates, putting data security and resilient design at first place, editing system files only within the boundaries of text-markers "# BEGIN slackcloud" and "# END slackcloud" ; and  touching nothing of the filesystem except its own staging directory before I deem the new code ready for production.

By now, Claude understands the ins and outs of Slackware and how it's different from other distros, but also the bot respects my own philosophy and how I want things to be done (no Unicode characters in text files please!). Call it "responsible use of AI"; yes you may mock me, I don't care.

Eventually the project deliverable will be a single Slackware package, which - once installed - will give you a "slackcloud" command-line tool plus a PyQt6 GUI. When installing Slack Cloud, you can do that via the CLI on a remote terminal and even if the server is headless, a SSH tunnel will let you run the GUI if you prefer to have the full setup program visible with 'previous' and 'next' buttons.

Keycloak is still used for the Single Sign-On but I am adding new services for which I had not written an article before: Matrix Chat (including Element Web), Dokuwiki (making use of the same farmer/sheep construct that also powers Slack Docs), and Forgejo. Still to add before I am satisfied with the result is Nextcloud AIO (all in one Docker image with Euro-Office, OpenOffice or Collabora Office, the choice will be yours) to complete a solid collaboration platform where a group of people can share and collaborate on documents, chat in realtime and have video conferences (guests allowed).
There will also be a built-from-spec admin page for an administrator to manage user accounts and group memberships a bit more elegantly than going into Keycloak's interface. The admin module will also allow for managing server backups and application upgrades.
A firewall will also be installed, with the rules automatically determined through the Slack Cloud services that are enabled (on top of your own local rules). For that, slackcloud will borrow a firewall generator engine which is another ongoing project of mine, called "Guardian Firewall Engine" which abbreviates to GFE. The abbreviation being a deliberate pun in honor of my ageing EFG (Easy Firewall Generator) at: https://alienbase.nl/efg/ this will be a re-implementation supporting IPv6 and based on nftables instead of iptables. Yet again a private repository on the Slackware Forge for now, but it will be opened up when the code is stable.

Slackcloud version 0.1.0 is already quite capable, fully supporting IPv6, and installs a variety of services, all running in Docker containers. The slackcloud tool also writes a static portal web page as shown in the screenshot where all of the installed web applications are easily accessible. Yes, those are real hostnames, and yes, I am confident that you'll be unable to access them without account. The bots have already found these sites minutes after going live anyway.
You'd also experience when you visit this page, that the Wiki site is still under lockdown (i.e. not released to the public) as an example of how a deployment can stay under the radar until the administrator is satisfied with the initial setup and decides it's time to invite the users.

Your comments and suggestions are welcome as always. Would you use this tool when it becomes available? What would be your primary concern? Why would this be an essential new capability for Slackware users?

Please try to avoid devolving the discussion into an anti-AI campaign, I am not interested in those comments.

Cheers, Eric


This is the example slackcloud.yaml file which the slackcloud package will install to '/etc/slackcloud/slackcloud.yaml'.
When installing (or "applying") the Slack Cloud container stack to your server via the command "slackcloud apply -c /etc/slackcloud/slakcloud.yaml", this file determines the outcome of what gets installed:

# slackcloud.yaml - annotated reference configuration
# Lives at /etc/slackcloud/slackcloud.yaml on the target server (mode 0600).
# The PyQt6 wizard generates this file; editing it by hand and re-running
# 'slackcloud apply' is fully supported and is how you add applications later.

server:
  domain: example.org            # base domain; apps live on subdomains of it
  ipv4:
    enabled: yes                 # public IPv4 reachability (default: yes)
    public_ip: 203.0.113.10      # the address your A records point at
  ipv6:
    enabled: yes                 # public IPv6 reachability (default: yes)
    public_ip: 2001:db8::10      # the address your AAAA records point at
  # At least one family must be enabled. A flat 'public_ip: ' line from
  # older configs is still read as ipv4.public_ip, but you then also need to
  # set ipv6.enabled: no or add ipv6.public_ip.
  interface: eth0                # NIC carrying the public traffic
  admin_email: admin@example.org # Let's Encrypt registration + cron mail

branding:
  # Place your assets in /etc/slackcloud/branding/ (any absolute path works;
  # these are examples, not fixed locations). Both files must exist: apply
  # refuses at validation with "logo not found at " rather than
  # producing an unbranded login page. A changed file is picked up by the
  # next 'slackcloud apply' and re-propagated by content comparison.
  favicon: /etc/slackcloud/branding/favicon.ico   # Keycloak theme and admin panel
  logo: /etc/slackcloud/branding/logo.png         # login screens; PNG or SVG

docker:
  install: yes                   # no = verify presence, abort early if missing
  data_root: /var/lib/docker     # change if /var is small
  network_pool: 172.31.0.0/16    # internal IPv4, one /24 per application stack;
                                 # always used, also on IPv6-only hosts
  ipv6_networks: no              # yes = container networks also get a /64
  network_pool6: fd00:5c10::/48  # ULA range carved into /64s (only read when
                                 # ipv6_networks is yes)
  loopback_port_base: 18080      # first 127.0.0.1 port for proxied container
                                 # ports; allocated upwards, recorded in state

keycloak:
  realm: mycloud
  hostname: id.example.org       # default: id.
  admin_password: ask            # 'ask' = prompt; the GUI offers to generate
  # Applications whose app- group every NEW user joins (Keycloak realm
  # default groups; users that already exist are not added). Keycloak refuses a
  # sign-in to an application unless the user is in its app- group (or a
  # subgroup) or in cloud-admins, so this is how a new member gets in at once.
  # Default: [matrix] when matrix is enabled, otherwise none; [] means none.
  # Every name must be an enabled application (DESIGN.md 6).
  # default_groups: [matrix]
  # Failed or refused sign-ins before Keycloak locks a user out of NEW sign-ins for a
  # minute (more for each further batch of this many, at most fifteen minutes). Refusals
  # by the access gate count too, and slackcloud turns Keycloak's quick-login check off.
  # Converged on every apply, so set it here rather than in the console. Minimum 3.
  # failure_factor: 10

# Every app also accepts an optional image_tag (e.g. "image_tag: 15.1.2"),
# overriding the module's own tested pin (DESIGN.md 7, "Pinned container
# images"). A deliberate deviation from a tested combination: slackcloud
# does not re-verify an administrator's chosen tag the way it does its
# own pins.
apps:
  jellyfin:
    enabled: yes
    hostname: media.example.org  # default: media.
    media_path: /srv/media       # bind-mounted read-only into the container

  affine:
    enabled: yes
    hostname: notes.example.org

  forgejo:                       # git forge, HTTPS only, OIDC via Keycloak
    enabled: yes
    hostname: forge.example.org  # default: forge.
    # image_tag: 15.0.8           # optional override; see the note above

  dokuwiki:                      # deployed as a farm; see DESIGN.md section 7
    enabled: yes
    hostname: wiki.example.org   # default: wiki.

  matrix:
    enabled: yes
    hostname: matrix.example.org     # homeserver (Tuwunel)
    element_hostname: chat.example.org
    serve_well_known: yes            # well-known discovery on the apex vhost; with
                                     # federation off only the client file is served
    federation: no                   # no (default) = a fully contained community, nothing
                                     # exposed to other Matrix servers; yes = federate
                                     # (see DESIGN.md 7)
    element_call: yes                # Element Call (MatrixRTC): LiveKit and lk-jwt-service,
                                     # so Element X, the mobile app, can place and answer
                                     # calls (it supports nothing else). no = voice and
                                     # video from Element Web only (DESIGN.md 7)
    rtc_hostname: rtc.example.org    # LiveKit and lk-jwt-service; needs a DNS record and a
                                     # certificate; opens udp 7882 and tcp 7881

  nextcloud_aio:
    enabled: yes
    hostname: cloud.example.org
    # AIO manages its own containers and network; slackcloud verifies that
    # the network it creates does not collide with anything, then records it.

  jitsi:
    enabled: no
    hostname: meet.example.org
    guests: yes                  # people without an account join a meeting a member has started;
                                 # no: everyone signs in. Only app-jitsi and cloud-admins start one.
    p2p: no                      # yes: a call of two goes peer-to-peer (this host's own STUN server);
                                 # the browsers then exchange real LAN addresses, so a guest learns a
                                 # member's (SECURITY.md AR-17). Needs turn: auto. Default no: a call
                                 # of two goes through the video bridge.

  adminpanel:
    enabled: yes                 # strongly recommended; this is your user admin
    hostname: admin.example.org

# TURN: one coturn for the whole host, used by Matrix (Tuwunel, LiveKit) and Jitsi. It is an
# internal module: never listed under apps:, enabled by itself when an application needs it.
# This section is optional; every key has a default (DESIGN.md 7, "TURN").
turn:
  enabled: auto                  # auto: on when an application needs it (default);
                                 # no: decline it. Each application then renders without it, and
                                 # preflight, apply, POSTINSTALL and status say what stops working
                                 # (Jitsi: guests behind UDP-blocking networks cannot join; Matrix:
                                 # no relay for calls). An external TURN server is planned.
  hostname: turn.example.org     # needs a DNS record and a certificate, no web vhost
                                 # (default: turn.)
  relay_ports: "49152-49351"     # the UDP media relay range; the firewall opens exactly this range

certs:
  # The ACME directory dehydrated talks to. Anything other than the Let's
  # Encrypt production directory issues certificates browsers do not trust;
  # 'slackcloud status' says so. Changing it re-issues every certificate.
  acme_directory: https://acme-v02.api.letsencrypt.org/directory
  # Let's Encrypt staging (no rate limits, untrusted certificates):
  #   https://acme-staging-v02.api.letsencrypt.org/directory
  # A local Pebble test server (https://github.com/letsencrypt/pebble; see
  # tests/pebble/README.md), on the *same host* dehydrated runs on:
  #   https://localhost:14000/dir
  #
  # ca_bundle: a CA file dehydrated must trust to reach acme_directory at all
  # (not the certificates it issues; that is a separate, unrelated trust
  # decision). Required for a private or local ACME server such as Pebble,
  # whose own endpoint certificate is signed by a CA the system does not know;
  # not needed for Let's Encrypt production or staging, both served over a
  # publicly trusted certificate regardless of what they issue.
  #   ca_bundle: /etc/slackcloud/pebble.minica.pem
  #
  # trust_system_store: yes overrides the requirement above, for the rare case
  # where the directory's own certificate is already in this host's trust
  # store. Rejected by default: the check exists because the failure mode
  # otherwise looks like "curl returned with 60" for no apparent reason.

backup:
  schedule: "30 3 * * *"         # root crontab entry, dcron syntax
  retention_days: 14
  destination: /var/lib/slackcloud/backups

firewall:
  # The ruleset is generated from this block plus each application's own
  # port declarations; application ports are never listed here. Omitting
  # the whole block means "protected with defaults", not "open".
  enabled: yes                   # only an explicit 'no' leaves the host unprotected
  backend: nftables              # the only backend in v1
  ssh_port: 22
  ssh_allow_from: [any]          # or CIDRs of an enabled family, e.g. [203.0.113.0/24, 2001:db8::/32]
  extra_open_ports: []           # non-slackcloud services on this host, e.g.
                                 #   - {port: 25, proto: tcp, from: [any], comment: "smtp"}
                                 #   - {port: "60000-61000", proto: udp, comment: "mosh"}
  icmp: yes                      # keep PMTUD working, especially on IPv6
  log_drops: no                  # rate-limited logging of dropped packets

setup_lockdown:
  # A newly deployed application is unconfigured until the administrator
  # finishes its first-run setup; until then its vhost accepts only these
  # sources (DESIGN.md 19). Required whenever enabled (the default): there
  # is no safe default admin_access_from, since defaulting to "everyone"
  # would defeat the point. 'slackcloud release ' (or --all) lifts
  # the restriction once setup is done; re-running apply never re-locks a
  # released service or releases a locked one.
  enabled: yes
  admin_access_from: [203.0.113.0/24, 2001:db8:1234::/48]