Best. Lecture. Ever. This episode is clearly the source of the “PG” promise of nudity, despite steam and chibification keeping things squeaky clean. And I’m confident the steam was not a buy-the-Bluray tease; it’s not that kind of show.

Anyway, along with limestone deposits, we get a discussion of future plans, and to the surprise of absolutely nobody, Nagi wants to teach, Shoko wants to become Yoko, and Ruri stumbles on her answer with a little help from her friends. The series closes with a montage of the near future, and a glimpse at Ruri’s suspiciously-familiar adult form.

Corn, popped

Literally for once. I hadn’t planned on making caramel corn Sunday night, but out of nowhere, my mother asked me how much unpopped corn you need to make 8 quarts of popcorn. She’d found a recipe for caramel corn somewhere, and it assumed you knew the conversion ratio. I ended up at popcorn.org, which says 2 TBSP of kernels for a quart of popped corn.

They also had a smaller, allegedly easier recipe that only required 5 quarts of the white stuff.

It somehow ended up being my job to run the air popper and follow the recipe, and the only difficulty was that the premium popcorn they’d bought produced significantly more volume than expected. 8 TBSP of kernels would have been more than enough.

I suspect I’ll also be drafted into making the next batch, this time with nuts.

Reminder: I am not actually this fat or this bald, I have much better trigger discipline, and I’m left-handed. Qwen is, shall we say, “not good” at guns, and definitely has a problem with the concept of holsters:

(I didn’t even ask to be holding the gun, just “holstered at his left hip”)

Diablo 4, season 10

I generally start new seasons with a Necromancer minion build, because being escorted by a pack of skellies does a good job of keeping you from getting overwhelmed at low levels as you acquire not-entirely-crappy gear and start to build up cash, materials, and abilities. Once you get some rare drops, it becomes an easy way to reach Torment 4 (Hand of Naz unique gloves, Nagu and Ceh runes, and Aspect of Occult Dominion cast on a helmet give you 14 skeletal mages and six spirit wolves to do your killing).

I’m currently farming in T3 because it’s faster, trying to get an Ophidian Iris for my incinerate/hydra sorcerer. I also thought I’d need some uniques to build up a whirlwind barbarian, but they’re letting you powerlevel alts through the seasonal content again, so I unlocked Deafening Chorus at level 30, and I already had an item enchanted with Aspect of Fierce Winds (DC = shouts are always active at +50%, AoFW = activating a shout creates 3 dust devils). The Neo and Ceh runes are another way of creating a pack of spirit wolves, so damage just kinda happens while you run around. And you’re also berserk and unstoppable at all times, with increased damage reduction and speed, making farming less of a chore.

(this is approximately 10% as chaotic as actually playing this build)

Reminder: X hallucinates your “interests”

If your feed seems skewed, it’s time to go in and uncheck the auto-generated horseshit “interests”. This week, mine was:

Not only have I never engaged with any tweet on most of these subjects, most aren’t even things that someone I follow would make fun of. And for the few that were memed by someone, that context should be taken into account. Pointing and laughing at something doesn’t mean you want to see more of it.

The only nice thing I can say about this list is that it’s just garbage, not explicitly hard-Left garbage.

Random randoms of randomness

Someone on the SwarmUI Discord posted a complex prompt that uses the app’s native randomizing syntax to create a wide variety of people portraits with diverse (both meanings) faces. It’s like a Perl one-liner had sex with a MadLibs book:

(analog photography.:2) in <random:an indoor|an outdoor|a studio> setting.
<random:<setvar[gender,false]:man><setvar[pronoun_n,false]:he><setvar[pronoun_p,false]:his>|<setvar[gender,false]:woman><setvar[pronoun_n,false]:she><setvar[pronoun_p,false]:her>|<setvar[gender,false]:person><setvar[pronoun_n,false]:they><setvar[pronoun_p,false]:their>>the <var[gender]> is in <var[pronoun_p]> <random:early|late|> (<random:teen years|twenties|thirties|forties|fifties|sixties|seventies|eighties>:2)..
<var[pronoun_n]> has a distinctive <random:oval|round|square|heart-shaped|long|oblong|diamond|triangular> face, looking <random:pleasant with a gentle smile|energetic with a broad smile and a cheerful grin|radiant, beaming with joy and sparkled eyes|amused, with a slight smirk and a twinkle in the eye|contended, in a peaceful and serene expression|playful, with a mischievous glint, hinting at fun|warm and welcoming|hopeful and optimistic|blissful, lost in happy thoughts|thoughful, deeply pensive|curious, eyes wide with interest and head tilted on a side|observant and scrutiny|introspective, lost in reflection|calm and peaceful|serene, untroubled|focused, intently concentrating|weary and exhausted|melancholic and wistful|pensive with a hint of sadness|resigned in acceptance|wistful, longing for the past|anxious with worry in the eyes|reserved, keeping it formal|overjoyed in exhuberant happiness|very sad in a genuine sorrow with tears|angry, bursting in rage|surprised, startled with wide-eyed wonder|fearful, apprehensive and scared|determined with strong will and resolve|intense, experiencing a deep feeling|smiling sadly|thoughtfully amused|weary but determined|curiously spektikal and doubtful|serenely hopeful>.
<var[pronoun_n]> has <random:porcelain|ivory|rosy-fair|pale golden|peach|golden|olive|light tan|tan|bronze|caramel|warm brown|cool brown|chocolat|deep bronze|ebony|rich dark brown|honeyed|copper|russet> <random:flawless|velvety|polished|dimpled|porous|weathered|sun-kissed|bumpy|freckled|densely freckled> <random:skin with <random:small,large, prominent> moles|skin  with <random:faint, noticeable, prominent> (scars:<random:1,2,3,4,5>).|skin>, <random:pixie cut|buzzcut|chin-length|jawline-length|shoulder-length|collarbone-length|mid-back length|waist-length|long|classic bob|layered bob> <random:jet black|raven black|soft black|chocalate brown|dark mahogany|chestnut brown|medium brown|light brown|ash brown|auburn|platinum blonde|golden blonde|honey blonde|strawberry blonde|ash blonde|dirty blonde|fiery red|ginger red|burgundy|silver gray|charcoal grey|snow white|salt-and-pepper|bronze|mahogany|russet|ombre|blue> hair with a <random:high hairline|low hairline| widow's peak|straight hairline>; <random:high|medium|low> and <random:wide|narrow|average> <random:sloping|straight|with prominent brow bone> forehead.
<var[pronoun_p]> <random:sparse|dense|regular|asymmetrical> eyebrows are <random:thin|medium|thick|bushy> and <random:arched|straight|angled upward|angled downward|rounded|curved>, <random:matching hair color|darker than hair|lighter than hair>, <random:almond-shaped|round|upturned|downturned|hooded|monolid|> <random:large|medium|small> eyes show a beautiful <random:sky blue|deep sapphire blue|grey-blue|turquoise|emerald green|olive green|hazel green|dark chocolate brown|light hazel brown|golden brown|mahogany brown|mixture of brown, green, and gold|silver grey|slate grey> hue<random:|, deep-set into <var[pronoun_p]> face|, protruding forward>, <random:short|medium|long> <random:sparse||thick> <random:straight|naturally curled|heavily curled with mascara> eyelashes.
<var[pronoun_n]> sports a <random:large|medium|small|pointed> <random:straight nose, with a classic and balanced profile|roman nose with a prominent bridge and a hump|greek nose, with a straight bridge and refined tip|snub nose, upturned and delicate|aquiline nose, hooked and curved downwards|button nose, nicely rounded|hawk-like nose, strong and prominent|wide nose, broad at the nostrils|narrow nose with a thin bridge|long nose, extended length from brow to tip>, <var[pronoun_p]> cheeks are <random:rosy, naturally flushed|dimpled with cute indentations|freckled|sun-kissed|sculpted sharp|softly curved>. <var[pronoun_n]> has <random:large|medium|small> <random:full, voluminous|thin, delicate|wide, spreading across <var[pronoun_p]> face|distinctive bow-shaped|softly curved round|down-turned drooping|> <random:lips.|lips with a defined cupid's bow.|lips with a prominent lower lips.|lips with a prominent upper lips.> <var[pronoun_p]> chin is <random:large|medium|small|strong|weak> and <random:rounded|square|pointed|cleft|receding|prominent|doubled, with fullness under the chin>, <var[pronoun_n]> has a <random:strong|soft|square|rounded|well defined|soft> and <random:wide|narrow> jawline, completing <var[pronoun_p]> face.
<var[pronoun_p]> build is <random:slender|lean|muscular|stocky|robust|petite|large-framed>, <var[pronoun_n]> stands in an <random:upright|slouching|stooped|relaxed|casual|tense|stiff> posture, showcasing <var[pronoun_p]> <random:broad|wide|narrow|sloping|rounded|square> shoulders and <random:full|flat|narrow> chest. <var[pronoun_p]> arms are <random:long|short|muscular|toned|slender|lean|strong|robust>, completed with <random:delicate|rough|small|large> hands.
<var[pronoun_n]> wears a <random:formal|casual|loose|fitted|tight> <random:cotton|silk|wool|denim|leather> <random:shirt|blouse|t-shirt|sweater|jacket> contrasting with <var[pronoun_p]> hair.

…and that’s why I converted it to the dynamicprompts YAML format, which revealed all sorts of typos and awkward phrasing. I added weighting to improve realism (completely random choices produce a lot of unusable crap), cleaned up the option lists, and added a new one to push Qwen Image away from its default faces.

My version is here, in my new Github repo for random genai-related stuff. The Python script I use as a wrapper for the dynamicprompts library is in there, too.

You know it’s time for a new theme when…

…you weed 500 images down to 162 and say, “forget the toes, maybe I’ll just use them all as wallpaper”. I’m not going to blog that many, though, so I deathmatched it down to 18 based on the newly revised-and-randomized sfnal locations.

I started with ~900 retro-sf locations generated by several different online and offline LLMs, fed them all to Claude to categorize and create sentence patterns, and then threw 500 imaginary pretty girls on top. Many of the results were visually incoherent, and quite a few had nothing about them that even hinted at SF, retro or otherwise, but most met the goal of being lively and colorful without drawing attention away from the girl.

No refine&upscale for this batch; it’ll run overnight for the full set of 162, so I probably won’t kick it off today.

more...

It has been at least 45 years since I last thought about crystal radios. Mine was a kit, probably from Radio Shack because there was still such a place, and it didn’t hold my interest long. If only I’d known the attraction it held for rock-junkies and their busty allies, things could have been different.

Anyway, Ruri finds her grandfather’s homemade set (while looking for his rocks, of course), has no idea what it is, and since there were crystals inside the box, heads off to Nagi to find out what’s what. Nagi and Imari are too busy to give the girls more than a quick lecture and a shopping list, but Busty Gal Pal Aoi gets pressed into (and for) service and ends up enjoying the adventure.

Frustration over the weak signal leads them to seek higher ground, and without realizing it, they end up at the same place grandpa tested it originally, a local shrine. The story’s all about connections, and in the end, the priest turns out to be connected, too.

And then Imari gets lucky, playing a classic trope straight to set up the next (and last) episode.

Future Waifu Society

I genned a batch of retro-sf cheesecake Thursday with the Pin-up Girl and SNOFS LoRAs loaded (the latter at 50% strength), and… forgot to trigger them. Both have some influence on the output even without trigger words, but the net result was that the majority of the pictures were pretty much the same as the last batch of retro-sf gals, so I had to skew my deathmatch toward the ones that picked up at least a little of the pin-up aesthetic. Then I kicked off another batch on Friday with a new set of corrected prompts. Results of both sets below.

Next up? I had Claude tear apart the over-familiar SF location prompts and put them back together broken down by category and reassembled in a bunch of different patterns. The faster/cheaper Haiku 4.5 model didn’t manage to put 50 unique elements into each category, but it got at least halfway there before it started repeating itself. Combinatorially speaking, it’s capable of at least 10,000 unique locations, but I won’t know if they’ll be interesting until I generate some pics.

Also, the next batch should have less fashion and facial disasters, since I set the weights for feathers, spikes, and tongues to be much, much lower. Qwen doesn’t know what “feathered hair” or “spiked hair” mean, and tends to go a little overboard when those adjectives are used anywhere. And mentioning a tongue guarantees an exaggerated expression where it’s stuck out at the viewer, and usually not in a sexy way. Still running about 4% limb disasters, though, and that’s being generous.

First batch

The refine/upscale process is working pretty well now, with one small problem: toes. They were fine before upscaling, sigh, so don’t count them or point out that the big toe (if any) is on the wrong side. Sigh.

more...

Imari takes the lead again, with Nagi off to a conference in America until the end of the episode. Growing into the mentor role, Imari gives Our Girls another way to look at rocks, and a field test inspires Ruri to begin thinking like a scientist, leading the team to search for supporting evidence on the sapphire’s origins. Which they find, tying in the local mythology again.

By the way, I happened to catch the name of the school, 前芝 = Maeshiba = “front lawn”. It doesn’t appear to be a real place, unlike some of the other locations used in the show, which are scattered across Japan in ways unreachable as day-trips in Nagi’s car.

(the real name of the school should be Waifuhaven College…)

Dear Slashdot summarizer…

I think you should reconsider your use of the word “despite” here:

The heightened scrutiny comes as Microsoft prioritizes investment in generative AI while overseeing a gaming division that has struggled despite spending $76.5 billion on acquisitions.

Related,

The unholy love child of Clippy and Bob has arrived. Mico the animated Copilot avatar will be turned on by default.

This bubble can’t burst fast enough.

Also related,

New study: AI chatbots systematically violate mental health ethics standards

Whipped cream and other delightsmagical girls

Taking over the world, one desk at a time, Baiser/Leoparde style.

Stick a pin-up in it, it’s done

While the previous LoRA met the goal of adding a bit of flavor to the cheesecake, it’s not stable yet, doesn’t play well with others, and its nude side is overtrained on fake boobs. SNOFS has better variety there, but really wants to go hardcore, which is not what I’m looking for in cheesecake wallpaper. Enter Pin-up Girl, which captures the classic pin-up aesthetic and doesn’t turn pretty girls into melty mutants when combined with half-strength SNOFS.

The results were encouraging, and the refine/upscale process only introduced relatively minor flaws (changed facial expressions, some really distorted background items, etc) , so I didn’t have to reject a bunch and try to remake them:

more...

“In that moment, Imari grew up.”

This week, Imari flies solo. More precisely, Nagi can’t join the Let’s Explore A Manganese Mine expedition, so Our Big Little Bookworm’s insecurities come to the fore as she takes responsibility for the girls in territory none of them have visited before. Shoko is adorably confident in her chosen mentor, but Ruri gets a wee bit too snarky when deprived of her idol.

A tunnel collapse keeps them from reaching their destination, and that’s when a well-researched novel comes to the bookworm’s rescue. All’s well that ends well, and while Imari isn’t ready to fill Nagi’s… “shoes”, she doesn’t disappoint.

More GenAI Faprication

🎶 🎶 🎶 🎶
And I would gen 500 wives,
    and I would gen 500 more.
Then quickly deathmatch through those thousand wives,
    and blog the ones ranked 4.
🎶 🎶 🎶 🎶

This time around, we have a Qwen LoRA that actually works. Most of the ones I’ve tried have either changed nothing detectable or were overtrained to the point of making everything worse. Our new friend is Experimental-Qwen-NSFW, which has a very strong anime bias, and adds a touch of naughty even to prompts that don’t push its buttons. Also elf-ears and the occasional tail.

I used the revised-and-expanded retro-sf location & costume prompts, the new physical-expression-based moods, and the rest was unchanged. The LoRA exaggerated the poses and facial expressions, and despite its flaws (strange fingers, extra limbs, knock-knees, and “poorly-set broken bones” being quite common), it livened things up nicely. It even added some Moon diversity.

Downside: the refine&upscale pass had a tendency to magnify the LoRA’s flaws. In one case, it took two perfectly normal hands and added extra fingers in odd positions. In another, it changed the poses of the men in the background to match the gal’s sexy walk, which just looks goofy. About a dozen of them were made objectively worse, and another half-dozen had changes I didn’t care for, even if you wouldn’t know unless you saw the original. This is using the commonly-recommended 4xUltrasharpV10 upscaler, but I get the same sort of changes with others.

I briefly flirted with a tool for converting the metadata to a CivitAI-compatible format for uploading there, but the author silently changed its defaults to overwrite your saved originals, destroying the original metadata that lets you reload the exact settings in SwarmUI and refine/upscale. Fortunately I tested it on only one image. It also prefers to destructively modify an entire directory at once, so, yeah, not linking to that tool’s repo. It’s a simple JSON massage to the EXIF data, so I’ll just roll my own at some point. Or have Claude do it.

Speaking of Claude, I gave up on using their suggested devcontainer approach in VS Code (which I didn’t really want to use anyway), and installed the node-based Claude Code CLI inside of a VMware virtual machine running Ubuntu 25. Code is rsynced to a shared folder to make it available inside the VM, so it can’t see anything else and can only operate on copies.

(these are the ones where the defects aren’t so bad I have to re-gen them with a variation seed; some that I almost included turned out to have mottled skin tones, mostly on the legs, and I like my waifuskin like I like my peanut butter: smooth and creamy; also, without nuts)

more...

I approve of Imari’s attempts to improve Nagi’s wardrobe. She looks good in anything, and fan-artists have gleefully expanded her range. This week, we bounce into a game of Opals For Oppai!

Interesting to see Ruri’s reaction to L’il Red Shoko choosing Imari as her preferred mentor. A small detail, but character-developing.

“How hard could it be?”

I sent my sister a sample screenshot from the work-in-progress gallery-wall app, and she asked if I could make it work for her, as she also has walls in need of galleries. Not being a command-line kind of gal, the ideal solution would be for me to use something like py2app to bundle in all the dependencies so she can drag-and-drop a directory onto a self-contained app.

Turns out that’s quite hard, at least if you’re Windsurf & Claude Sonnet 4.5. So hard, in fact, that in the end I told it to back out to the last commit before we started, and it gleefully did a git hard reset that erased all traces of its 90 minutes of failure. The app packaging went fine, after a few tries, it just couldn’t implement drag-and-drop or manage to quit cleanly. And the best part is that it learned nothing, and will make the exact same mistakes again tomorrow. Confidently, with exclamation points.

Pro tip: when your GUI app logs a line that says “run pkill to exit cleanly”, you have failed. Also, don’t gaslight the user by claiming that typing a directory name on the command line “is a better Mac-native solution than drag-and-drop”.

Breaking out the stone knives and bearskins, the simplest approach seems to be a three-line change to add a native-app wrapper with pywebview. py2app still blows chunks if you enable drag-and-drop, but at least it bundles up all the dependencies. The workaround is to use Automator to create another app that just launches the real one from a shell script with --args "$@", which is conceptually disgusting but functional.

(I had ChatGPT create an icon for the app (which takes a while when you don’t pay them $20/month…); it does not feature Our Mighty Tsuntail)

Our DFC Ponytail-Bearing Redheaded Schoolgirl Pal (currently only known by her last name, although now that she’s slipped up and called Our Crystal-Crazy Heroine Ruri-chan, she’s sure to be Shoko-chan soon) stumbles across an unusual orange rock, then stumbles and loses it, leading to a deep-woods adventure that wipes out even the energetic Ruri, terminating in an abandoned factory. Whatever they were producing, the conditions were just right for making big orange crystals, as explained by Our Well-Rounded Mentor.

Nagi’s wisdom is as deep as…

(by the way, this is only the second role for L’il Red’s voice actress)

There And Back Again

My wayward Amazon package finally arrived Friday night, and it was even intact (mildly surprising since it had no packaging whatsoever, just a label slapped on the side). There was no indication of how it went astray, like a second label or a half-dozen scenic postcards, but there is a punchline to the story.

The first entry in Amazon’s tracking has it starting out in San Diego, CA on the 28th. From there it went to: Cerritos, CA on the 29th; Hodgkins, IL on the 2nd; Bell, CA on the 6th; La Mirada, CA on the 7th; Hodgkins, IL and two cities in Ohio on the 9th; then the UPS depot up the street from me early on the 10th, and finally onto my front porch that evening.

The punchline? The shipping label on the package says it really shipped from Hebron, KY. Which is about an hour’s drive from my house.

(I guess it just wanted a little more flight time)

The worst thing about Larry Correia’s Academy Of Outcasts…

…is that it convinced Amazon I’m interested in ‘LitRPG’, a genre I have repeatedly run away screaming from. Not just because the genre is cursed with premature subtitlisis and epicia grandiosa, things that have been turning me away from overambitious new authors for decades.

The book? Fun, although I kept getting distracted by on-call alerts, so it wasn’t an in-one-sitting kind of read. I’ll buy the next one.

(announcing your Grand Epic Plans on the cover of your first novel is a curse that was infesting the SF/fantasy mid-list back when publishers used to sign damn near every first-time novelist to a three-book contract with ambitious delivery dates, only for both sides to discover that it takes more than a year to write a decent sequel to a book that was written part-time over five years)

“You’ve heard of ‘filthy rich’? We’re ‘disgusting’”

In the end, I didn’t have Claude restructure the YAML file from $color/$loc/$time/$type to scene/$type/$color/$log/$time; instead I had the bright idea of molesting it with a one-liner (unpacked for clarity):

grep : scenes.yaml |
    perl -ne '
        next if /^#/;
        ($s,$k) = m/^( *)([^:]+):$/;
        $i = int(length($s)/2);
        $p[$i] = $k;
        print "." . join(".", @p[0..$i])," ",
            join("/", @p[0,4,1,2,3]),"\n" if $i == 4
    ' |
    sort -k2 |
    while read a b; do
        echo "# $b"
        yq $a scenes.yaml
        echo
    done

TL/DR: I used the indentation level to populate an array, printed out the original structure as a yq selector and the new structure as a path, sorted by the new path, then dumped out each section. After that it was a single search-and-replace to indent all the items, and a quick Emacs macro to convert the paths into the new YAML structure. The thing that took the longest was removing the redundant indented keys, which technically wasn’t necessary to create the correct YAML structure.

Probably took less time than writing an explicitly detailed request to Claude.

Waifu Harem Rotation

To overcome the Apple-imposed limitations on wallpaper changes, I instructed Claude to write a little Python script that shuffles separate sets of images for each display at a chosen interval. I called it waifupaper, of course:

#!/usr/bin/env python3
"""
Waifupaper - Changes MacOS wallpapers at fixed intervals

Bugs:
- doesn't work if wallpaper is currently set to rotate.
- fails to load images if called without full path to directories.
"""

import argparse
import os
import random
import subprocess
import sys
import time
from pathlib import Path
from collections import defaultdict


def get_directory_state(directory):
    """Get the current state of a directory (modification time and file count)."""
    directory = Path(directory)
    try:
        # Get the directory's modification time
        mtime = directory.stat().st_mtime
        # Count image files
        image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.tif', '.heic'}
        file_count = sum(1 for f in directory.iterdir() 
                        if f.is_file() and f.suffix.lower() in image_extensions)
        return (mtime, file_count)
    except Exception:
        return None


def get_image_files(directory):
    """Get all image files from a directory."""
    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.tif', '.heic'}
    directory = Path(directory)
    
    if not directory.exists():
        print(f"Error: Directory '{directory}' does not exist", file=sys.stderr)
        sys.exit(1)
    
    if not directory.is_dir():
        print(f"Error: '{directory}' is not a directory", file=sys.stderr)
        sys.exit(1)
    
    images = [
        str(f.resolve()) for f in directory.iterdir()
        if f.is_file() and f.suffix.lower() in image_extensions
    ]
    
    if not images:
        print(f"Error: No image files found in '{directory}'", file=sys.stderr)
        sys.exit(1)
    
    return images


def get_display_count():
    """Get the number of connected displays."""
    try:
        # Use system_profiler to get display information
        result = subprocess.run(
            ['system_profiler', 'SPDisplaysDataType'],
            capture_output=True,
            text=True,
            check=True
        )
        # Count occurrences of "Display Type" or "Resolution"
        count = result.stdout.count('Resolution:')
        return max(1, count)  # At least 1 display
    except subprocess.CalledProcessError:
        return 1  # Default to 1 display if command fails


def set_wallpaper(image_path, display_index=0):
    """Set wallpaper for a specific display using AppleScript."""
    # AppleScript to set wallpaper for a specific desktop
    script = f'''
    tell application "System Events"
        tell desktop {display_index + 1}
            set picture to "{image_path}"
        end tell
    end tell
    '''
    
    try:
        subprocess.run(
            ['osascript', '-e', script],
            check=True,
            capture_output=True
        )
    except subprocess.CalledProcessError as e:
        print(f"Warning: Failed to set wallpaper for display {display_index + 1}: {e}", file=sys.stderr)


def main():
    parser = argparse.ArgumentParser(
        description='Rotate wallpapers on Mac displays at fixed intervals',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  %(prog)s ~/Pictures/Wallpapers
  %(prog)s ~/Pictures/Nature ~/Pictures/Abstract -i 60
  %(prog)s ~/Pictures/Wallpapers -s -i 120
  %(prog)s ~/Pictures/Nature ~/Pictures/Abstract -1 -3
        '''
    )
    
    parser.add_argument(
        'directories',
        nargs='+',
        help='One or more directories containing wallpaper images'
    )
    
    parser.add_argument(
        '-i', '--interval',
        type=int,
        default=30,
        help='Interval in seconds between wallpaper changes (default: 30)'
    )
    
    parser.add_argument(
        '-s', '--sort',
        action='store_true',
        help='Sort images instead of shuffling (default: shuffle)'
    )
    
    parser.add_argument(
        '-1', '--display1',
        action='store_true',
        help='Only affect display 1'
    )
    
    parser.add_argument(
        '-2', '--display2',
        action='store_true',
        help='Only affect display 2'
    )
    
    parser.add_argument(
        '-3', '--display3',
        action='store_true',
        help='Only affect display 3'
    )
    
    parser.add_argument(
        '-4', '--display4',
        action='store_true',
        help='Only affect display 4'
    )

    parser.add_argument(
        '-v', '--verbose',
        action='store_true',
        help='print verbose output'
    )
    
    args = parser.parse_args()
    
    # Determine which displays to affect
    selected_displays = []
    if args.display1:
        selected_displays.append(0)
    if args.display2:
        selected_displays.append(1)
    if args.display3:
        selected_displays.append(2)
    if args.display4:
        selected_displays.append(3)
    
    # If no specific displays selected, affect all displays
    affect_all_displays = len(selected_displays) == 0
    
    # Validate interval
    if args.interval <= 0:
        print("Error: Interval must be a positive number", file=sys.stderr)
        sys.exit(1)
    
    # Get display count
    num_displays = get_display_count()
    if args.verbose:
        print(f"Detected {num_displays} display(s)")
    
    # Validate selected displays
    if not affect_all_displays:
        for display_idx in selected_displays:
            if display_idx >= num_displays:
                print(f"Warning: Display {display_idx + 1} selected but only {num_displays} display(s) detected", 
                      file=sys.stderr)
        # Filter out invalid display indices
        selected_displays = [d for d in selected_displays if d < num_displays]
        
        if not selected_displays:
            print("Error: No valid displays selected", file=sys.stderr)
            sys.exit(1)
    
    # Prepare image lists for each display
    display_images = []
    directory_states = {}  # Track directory modification times
    
    # Determine which displays will be managed
    if affect_all_displays:
        managed_displays = list(range(num_displays))
    else:
        managed_displays = sorted(selected_displays)
    
    if args.verbose:
        print(f"Managing display(s): {', '.join(str(d + 1) for d in managed_displays)}")
    
    for i in managed_displays:
        # Use the corresponding directory, or the last one if we run out
        dir_index = min(managed_displays.index(i), len(args.directories) - 1)
        directory = args.directories[dir_index]
        
        images = get_image_files(directory)
        
        if args.sort:
            images.sort()
        else:
            random.shuffle(images)
        
        display_images.append({
            'images': images,
            'index': 0,
            'directory': directory,
            'display_index': i  # Store the actual display index
        })
        
        # Track initial directory state
        directory_states[directory] = get_directory_state(directory)
        
        if args.verbose:
            print(f"Display {i + 1}: {len(images)} images from '{directory}'")
    
    if args.verbose:
        print(f"\nRotating wallpapers every {args.interval} seconds")
        print("Monitoring directories for changes...")
        print("Press Ctrl+C to stop\n")
    
    try:
        iteration = 0
        while True:
            # Check for directory changes before setting wallpapers
            for display_data in display_images:
                directory = display_data['directory']
                current_state = get_directory_state(directory)
                
                # If directory state changed, reload images
                if current_state != directory_states.get(directory):
                    display_num = display_data['display_index'] + 1
                    if args.verbose:
                        print(f"📁 Directory changed: '{directory}' - reloading images...")
                    
                    new_images = get_image_files(directory)
                    
                    if args.sort:
                        new_images.sort()
                    else:
                        random.shuffle(new_images)
                    
                    display_data['images'] = new_images
                    display_data['index'] = 0
                    directory_states[directory] = current_state
                    
                    if args.verbose:
                        print(f"   Loaded {len(new_images)} images for display {display_num}\n")
            
            # Set wallpaper for each display
            for display_data in display_images:
                images = display_data['images']
                current_index = display_data['index']
                actual_display_idx = display_data['display_index']
                
                image_path = images[current_index]
                image_name = Path(image_path).name
                
                if args.verbose:
                    print(f"Display {actual_display_idx + 1}: {image_name}")
                set_wallpaper(image_path, actual_display_idx)
                
                # Move to next image, wrap around if needed
                display_data['index'] = (current_index + 1) % len(images)
                
                # Reshuffle when we complete a cycle (if not sorting)
                if display_data['index'] == 0 and not args.sort and iteration > 0:
                    random.shuffle(display_data['images'])
                    if args.verbose:
                        print(f"  → Reshuffled images for display {actual_display_idx + 1}")
            
            iteration += 1
            if args.verbose:
                print()
            time.sleep(args.interval)
            
    except KeyboardInterrupt:
        if args.verbose:
            print("\n\nWallpaper rotation stopped.")
        sys.exit(0)


if __name__ == '__main__':
    main()

Fun fact: Apple’s virtual desktop ‘spaces’ have their own wallpaper settings, which means that each display has different wallpaper settings for each ‘space’. And if you want to keep the menubar on your main display, you have to tick the ‘use same spaces on all displays’ setting.

But ‘spaces’ are not manageable via Applescript, so changing wallpaper affects only the active space. Which means that if this script is running in the background, it will effectively follow you from space to space, updating the wallpaper on the active one. Which is kind of what I wanted anyway, but isn’t what the built-in rotation does. Apple’s standard behavior uses undocumented private APIs, which is a very Apple way to do things these days.

Work-still-in-progress

Revised the lighting & composition wildcards, revised the retro-SF costume wildcards. Next up will be throwing all the retro-SF location prompts into the Claude-blender and having it generate new ones broken down by category; not only are the current ones getting over-familiar, they come from several different models and a variety of prompts, with varying degrees of retro-SF-ness. After that I’ll probably throw the pose file at it; I did some manual categorization, but it’s still a real mish-mash of styles. Either that or the moods and facial expressions, which most models don’t handle well conceptually; I’m going to try asking for the physical effect of words like “happy”, “sexy”, “eager”, “playful”, “satisfied”, etc, and see if it produces something an image-generator can differentiate from “resting bitch face”.

Yet Another Example of words not to use with Qwen Image: the fashion term “cigarette pants” is taken literally, with half-smoked butts randomly placed around the hips. Only once did it put one in the gal’s hand, and I don’t think it ever interpreted it as “skinny pants”.

Also, I’m making a note to go through the costume components and downweight many of them; quilting and padding wear out their welcome quickly, especially when they get applied to gloves and make it look like she’s wearing oven mitts.

🎶 🎶 🎶 🎶
I won’t count fingers and toes,
   as long as you make pretty waifus,
Genai, you fool.

I won’t count fingers and toes,
   but I want limbs on the correct sides,
and each type should have only two.
🎶 🎶 🎶 🎶

(classical reference)

[wow, I must be tired and distracted by the combination of a houseguest and a busy on-call week; I didn't even notice that I never reviewed the episode...]

This week, The Tale Of The Abandoned Rock-Lover Who Finally Found a Home. With occasional really goofy face distortions that look like CGI rotations without the middle bits. On the plus side, we get one of Our Gals into a bikini. On the minus side, it's Ruri, who's definitely girl-shaped, but no competition even for Gal Gal, much less Our Varsity Over-The-Shoulder-Boulder-Holder Team.

The Tedium Express

That Package(TM) has moved again. Two days after leaving California, it was back to the same depot in Illinois that it visited a full week ago. And then it made it to (the other end of) Ohio Thursday night. Looking this morning, it appears to have reached the depot that’s literally down the street from my house.

So unless it goes back to California again, I should finally have it tonight.

Tell me you know nothing about legibility…

…without telling me you know nothing about legibility:

(also, “tell me you’re desperately hoping people will mistake your derivative crap for Japanese derivative crap…”)

More Claudification

I took a YAML file of lighting/composition/angle prompt components and threw it at Claude, instructing it to break them up into categories like indoor/outdoor, day/night, portrait/natural lighting, color/black-and-white, etc, then flesh out each category in the new YAML file up to 50. It worked quite well, with a few exceptions:

• the output wasn’t valid YAML; I had to correct several indentation errors, and two cases where it started a new category at the end of a line.
• it stopped twice and asked me to press the “Continue” button, because it took too long for a single request.
• the original file had a top-level “scene” key; this was deleted, and the new file’s structure’s structure looks like “color/outdoor/day/portrait”. The dynamicprompts library needs a top-level key for organization, which is trivial to add at the top and re-indent, but more annoying is that the hierarchy would make more sense as “scene/portrait/color/outdoor/day”, which is easier to add globbing to (“scene/portrait/color/*” to get both indoor and outdoor lighting at all times of day). This is a more difficult refactoring, so I’ll throw the corrected file back at Claude and tell it to do the grunt work.

Next up will be applying the same categorization and refresh to the settings, poses, and outfits, but not until I recover from having a houseguest this week…

more...

Just noticed that Crunchyroll has a PG rating for this show, promising nudity and profanity. So not happening.

Anyway, Ruri suffers a brief bout of imposter syndrome, then rereads her notes to discover that she did miss something, and only careful review kept them on the right track. In the end, they not only find the sapphires, but uncover a bit of local lore.

What sort of hills and valleys will they explore next?

…like our primitive ancestors did…

I rearranged things in my office so that the 4K vertical monitor sits between the MacBook Air and the Mini, connected to both. Given that both Macs have widescreen displays, naturally I configured the Dock to appear on the left, as I always do. Except that In Their Infinite Wisdom, Apple has decreed that if the Dock is on the left, it must appear on the left of the leftmost monitor, even if that is not the main monitor. You can force the menu bar to appear on the main monitor regardless of position, but if the Dock is on the side, it must be aaallllllllll the way to that side. Even if that’s literally several feet away from the display that’s right in front of your face.

So I had to move the Dock to the right of my laptop display, like some sort of heathen who eats from a dumpster. It’s quite unnerving. I don’t look there. I never look there. I have over twenty years of practice not looking there.

Someday my prints will come…

Amazon order for $RANDOM_OBJECT placed on September 28. Shipped via UPS on September 29. Until about an hour ago, the last update from UPS had it in Illinois on the 2nd, but now it’s arrived in… California!

I’m old enough to remember when Amazon was good at logistics. Also “packaging items so they don’t get destroyed in transit”.

Bookmarking for later,

OpenAI has discovered that it bought a pig in a poke with Jony Ive’s Mysterious Pocket AI Device. For 6.5 billllllllion dollars. To make it work, whatever “it” is, they not only need more AI server capacity, but also a better-than-their-flagship-chatbot to drive it. And the Ars commentariat will be there to do whatever it is they do.

They really should have asked Grok and Claude if this was a wise investment. Or maybe they did…

Claude dev containers in VS Code

Yeah, there’s a lot of hand-waving involved in how to do this, with no provision for “hey, your official Dockerfile blew chunks”. Meanwhile, I’m not the only person frustrated with Windsurf’s expensive failure policy. It does no good for them to have a polished GUI if it eats up your monthly credit balance in an AI-enhanced “abort, retry, fail” loop.

Not that I actually want to use VS Code with or without a vendor-specific skin on top. The only reason I even tried a pay-to-play “AI” IDE is that it produced a better coding experience for my initial test project (at no cost to me), and all of that goodwill was lost when the second project got bogged down and had to be spoonfed half a dozen screenshots to get it back on track. The vacation scheduler was over 50 passes in when I ran out of trial credits, with some functionality still untested because of blocking bugs, and it might have been able to fix them if it hadn’t eaten a bunch of credits.

Anyway, I bit the bullet and got a paid Claude subscription for a while, and if I can get their Coding UI to work in a secured sandbox, I’ll turn it loose and see what it does to the remaining bugs and feature requests. No chance in hell I’m going to give a Node.js “AI” app direct access to my shell…

(“no, you can’t tempt me; I know there’s node.js under that fur!”)

Wrong model!

I was reviewing image-generation prompts enhanced by an LLM, and ran across something worse than having it randomly switch to Chinese (which it also did):

Note: Please replace “her” with the appropriate pronoun depending on the woman’s gender.

Yeah, that one’s going in the trash heap. The LLM, not just the prompt. (it was a derivative of OpenAI’s free model)