John's Background Switcher

 

I use "John's Background Switcher" to display slide shows of the thousands of pics on my D drive as well as things coming in from various services, picked at random. In the past the application had a feature of saving to disk pictures coming in from the services, but it went away. Unfortunate and I would like to know if there is some other ways of just automatically saving to disk what is on the screen.

You are not imagining things — that feature was deliberately removed from John’s Background Switcher years ago because some photo services prohibited automatic downloading of full-size images through their APIs. The developer explicitly says “you’ll have to use another app” if you depended on it.

Fortunately, there are a few ways to accomplish what you want on Windows 11 without too much fuss.

The simplest possibility is to see whether JBS is already caching what it displays. JBS keeps a working cache of downloaded images and even has a “Cached Picture Browser” for montage modes. Sometimes the displayed image already exists locally in its cache folder even though the old “save everything” feature is gone. In JBS, look in More Settings → Import / Export → Open Folder and poke around. You may find a cache directory or the current wallpaper image (ActiveBackground.jpg) already sitting there.

If what you really want is: “Whatever happens to be on my screen as wallpaper, save it automatically into a folder forever,” then I think the cleanest approach for a former programmer analyst is a tiny scheduled script.

Windows keeps the current desktop wallpaper path in the registry. A small PowerShell script can run every minute (or every 5 minutes), check the current wallpaper, and if it is new, copy it to a “Saved Wallpapers” folder. That avoids screen scraping entirely and preserves the original file when available.

Something like this:

$dest = "D:\SavedWallpapers"
if (!(Test-Path $dest)) {
    New-Item -ItemType Directory -Path $dest
}

$wallpaper = Get-ItemPropertyValue `
    -Path "HKCU:\Control Panel\Desktop" `
    -Name WallPaper

if (Test-Path $wallpaper) {
    $name = Split-Path $wallpaper -Leaf
    $target = Join-Path $dest $name

    if (!(Test-Path $target)) {
        Copy-Item $wallpaper $target
    }
}

You could have Windows Task Scheduler run it every few minutes. Since JBS changes backgrounds at intervals, this would quietly accumulate anything new.

There is one caveat: some JBS sources may not leave the original image as the active wallpaper. JBS sometimes composites or resizes into an ActiveBackground.jpg, especially for montages. In that case you would still capture what you saw, but perhaps not the untouched original.

Another, almost embarrassingly simple option: if you only occasionally see something you love and want to keep, JBS has a tray menu with “View Current Picture” and sometimes “Save Background” depending on mode/version. That may already be enough if this is not happening ten times a day.

Given your setup — thousands of D: drive pictures mixed with internet sources — my instinct is that the PowerShell approach is probably the least annoying and most reliable. It feels very much like the sort of quiet utility one sets up once and forgets for ten years.

Your script will read what is in the registry as wallpaper rather than what is on the screen?

Yes — and that distinction matters.

The script reads the current wallpaper file path that Windows believes is the desktop background, not a screenshot of what is physically on the screen. So it captures the image Windows is using as wallpaper.

For ordinary wallpaper rotation, that is exactly what you want, because you get the actual image file rather than a screen capture with icons, scaling artifacts, or monitor effects.

The wrinkle is John’s Background Switcher. Depending on how JBS is configured, Windows may not point to the original downloaded image. Instead, JBS may generate a temporary file — often a resized, cropped, or composited image — and tell Windows, “Use this as wallpaper.” In that case, the registry path would point to that generated file, not the pristine original.

But it still would be what you are seeing as wallpaper, which I think is what you mean by “what is on the screen,” except without desktop icons or taskbar.

You can test this very quickly:

1. Wait until JBS displays a picture you recognize.

2. Open PowerShell and type:

Get-ItemPropertyValue `
  -Path "HKCU:\Control Panel\Desktop" `
  -Name WallPaper

It will print the file path Windows thinks is the wallpaper.

Then go look at that file. If it is the exact image you see, problem solved. If it turns out to be something like ActiveBackground.jpg in a JBS folder, open it — you may discover JBS has already been quietly saving exactly what you see.

My suspicion — and it is only a suspicion — is that with JBS you may find a cache or generated-image folder already holding far more than you realized. Older Windows wallpaper systems and programs often leave a trail of temporary images behind like breadcrumbs.

I think I would prefer whatever JBS shows anyway. Thing is I have it running background constantly, so that the slide show goes on all the time (it doesn't seem to affect performance at all), 24/7, changing every fifteen seconds.

Ah, with 24/7 operation and a 15-second interval, you are talking about 5,760 images a day. At that rate, you definitely do not want screenshots or manual saving.

In your case, reading the wallpaper path from the registry and copying the currently active wallpaper file is ideal, because it is lightweight and should have essentially zero noticeable performance impact — certainly less than JBS itself. Windows is already keeping track of the current wallpaper; the script merely peeks at it and copies it if new.

But with a 15-second cycle, I would adjust the approach slightly. You would want the task to run every minute or two, not every 15 seconds. Otherwise you will create an enormous number of duplicates and wear yourself out sorting them. Since the images are random, a one-minute interval still samples quite a lot — about 1,400/day — and catches many of the interesting internet ones.

If, however, you really mean save absolutely everything JBS ever displays, then the better strategy is not polling the registry but identifying where JBS stores its temporary or cached wallpaper image and copying from there automatically. Because JBS is changing every 15 seconds, it almost certainly rewrites a working file repeatedly.

A quick detective trick:

1. Let JBS run.

2. Open Task Manager → Details.

3. Right-click JBS and choose Open file location.

4. Poke around nearby folders, especially anything named:

   • Cache

   • Temp

   • Backgrounds

   • Images

   • ActiveBackground

Or simpler: after running the PowerShell command I gave, if it points to something like:

C:\Users\Frank\AppData\Roaming\John's Background Switcher\ActiveBackground.jpg

then you already have the answer. A tiny script could simply watch that file and save each changed version with a timestamped name:

$source = "C:\path\to\ActiveBackground.jpg"
$dest = "D:\SavedWallpapers"

if (!(Test-Path $dest)) {
    New-Item -ItemType Directory -Path $dest
}

$timestamp = Get-Date -Format "yyyy-MM-dd_HH-mm-ss"
$target = Join-Path $dest "wallpaper_$timestamp.jpg"

Copy-Item $source $target

Run every 15 or 30 seconds in Task Scheduler and you would quietly build an archive of exactly what JBS showed, cropped and composed exactly as seen.

One practical thought from an old data-handling perspective: at 15 seconds, disk accumulation becomes very real. Even modest JPEGs at, say, 1–3 MB each could mean several gigabytes a day. You may eventually want a filter such as “only keep internet images” or “only save once every minute.” Otherwise your D: drive may become a museum of wallpapers before long.

The vast majority of pictures coming up come from what is already on disk, and the services duplicate fairly often too, so maybe one in a hundred would actually go to disk.

Ah — that changes the economics entirely. If 99% are repeats, then you can afford to be much more liberal and simply let automation sort it out.

In that case I would add a duplicate check by file hash. That way the script can happily examine every wallpaper change, but only save genuinely new images. You would not care whether an image appeared 500 times; it would be stored once.

The idea is simple: every image has a kind of fingerprint (a cryptographic hash). When JBS changes the wallpaper, the script computes the fingerprint of the displayed image. If that fingerprint has already been seen, it skips saving. If not, it copies it to D:.

That means:

• Local D: images already in your collection → almost never saved.

• Service images you have seen before → skipped.

• Truly new incoming pictures → quietly archived.

• Repeats from services → ignored automatically.

For your use case, this becomes a “set it and forget it” background utility.

Something like this would work:

$source = Get-ItemPropertyValue `
    -Path "HKCU:\Control Panel\Desktop" `
    -Name WallPaper

$dest = "D:\SavedWallpapers"
$hashLog = "$dest\known_hashes.txt"

if (!(Test-Path $dest)) {
    New-Item -ItemType Directory -Path $dest
}

if (!(Test-Path $hashLog)) {
    New-Item -ItemType File -Path $hashLog
}

if (Test-Path $source) {

    $hash = (Get-FileHash $source -Algorithm SHA256).Hash
    $known = Get-Content $hashLog

    if ($hash -notin $known) {

        $ext = [System.IO.Path]::GetExtension($source)
        $timestamp = Get-Date -Format "yyyy-MM-dd_HH-mm-ss"
        $target = Join-Path $dest "wallpaper_$timestamp$ext"

        Copy-Item $source $target
        Add-Content $hashLog $hash
    }
}

Run it every 15–30 seconds via Task Scheduler, and it should quietly accumulate only genuinely new images.

Since you were a programmer analyst, one detail you will immediately notice: this is doing a linear search through a text file of hashes, which is perfectly fine for thousands of entries but eventually inelegant. If you wound up with tens of thousands of saved images, one could make it more civilized with a hash table or SQLite database. But for “odd interesting new wallpaper dribbling in from services,” the plain-text version is delightfully low ceremony and robust.

It has a certain old-fashioned Unix-tool spirit to it: tiny, boring, and dependable.

Let me clarify: I worked with old rule-based "AI," not code and while I knew Basic and Cobol and Pascal, my programming ability is now utterly obsolete and even then was aimed at mainframes, not Windows, so I do need some guidance on making scripts work.

That is helpful context, and it changes how I should explain this. You have the conceptual background, but not the accumulated Windows scripting habits, so the goal should be practical and low-risk, not clever.

I think the best thing is to do this in very small steps so nothing mysterious is happening.

First, we do not write a “program.” We create a plain text file containing commands, save it with a .ps1 extension (PowerShell script), and tell Windows to run it periodically.

The first experiment should be deliberately modest: just prove we can capture the current JBS wallpaper once. No automation yet.

Step 1 — Find what Windows thinks the wallpaper is

1. Click the Windows Start button.

2. Type PowerShell.

3. Click Windows PowerShell (or Terminal with PowerShell).

A blue-ish or black window opens.

Paste this one line and press Enter:

Get-ItemPropertyValue -Path "HKCU:\Control Panel\Desktop" -Name WallPaper

You should get back something that looks like a filename path, perhaps something like:

C:\Users\Frank\AppData\Roaming\John's Background Switcher\ActiveBackground.jpg

or perhaps something else.

Step 2 — Look at that file

Copy that path.

Open File Explorer and paste it into the address bar.

Questions we want answered:

1. Is it the same picture currently on your desktop?

2. Does it live in a JBS folder?

3. Do you see other nearby image files that look cached?

If the answer to #1 is yes, we are essentially done with the hard part.

Step 3 — Test a one-time copy

Only after we know the path works, we make a tiny script that copies the current wallpaper to a folder on D:.

You would:

1. Open Notepad

2. Paste in a few lines

3. Save as something like:

SaveWallpaper.ps1

4. Right-click and run it once.

Then we confirm it created a copy where expected.

Only then would we automate it with Task Scheduler.

The reason I am proposing this in stages is not because it is difficult, but because Windows scripting can fail for silly reasons (permissions, folder paths, PowerShell execution settings), and it is much easier to diagnose one small step than a whole contraption.

So for now, I would stop at Step 1 and simply tell me what filename/path PowerShell reports. That will tell us whether JBS is already handing us exactly what you want.

I think I will use my age as an excuse to back out of this, I'm considerably overwhelmed. I don't suppose an old-fashioned batch file would work; also hash would be overkill, just checking for duplicate file names would deal with it with maybe a one-in-a-million duplication since they use such huge unwieldy names.

Entirely fair. This is one of those things that sounds pleasantly simple in concept and then suddenly one is peering into PowerShell execution policies and registry keys and wondering why life became administrative.

And yes — for your situation, an old-fashioned batch file may be good enough, especially if filenames from the services are long and distinctive. You do not need industrial elegance here.

In fact, we can make this very simple and not overwhelming.

Here is the smallest plausible version:

1. Make a folder on D:, perhaps:

D:\SavedWallpapers

2. Open Notepad.

3. Paste this into it:

@echo off

for /f "tokens=2,*" %%A in (
'reg query "HKCU\Control Panel\Desktop" /v WallPaper'
) do set WALLPAPER=%%B

if not exist "D:\SavedWallpapers" mkdir "D:\SavedWallpapers"

set FILENAME=%~nxWALLPAPER%

if not exist "D:\SavedWallpapers\%FILENAME%" (
    copy "%WALLPAPER%" "D:\SavedWallpapers\"
)

4. Save it as:

SaveWallpaper.bat

Important: in Notepad, change “Save as type” from Text Documents to All Files, or Windows will secretly name it SaveWallpaper.bat.txt.

5. Double-click it.

That is it.

What it should do:

• Ask Windows what the current wallpaper file is.

• Look at the filename only.

• If a file with that same name is not already in D:\SavedWallpapers, copy it there.

• Otherwise do nothing.

No hashes, no databases, no cleverness.

Then, if it works and you like it, we can have Windows run it automatically every minute or every five minutes. But even that can wait.

You are not backing out due to age; you are exercising good engineering judgment. There is a real principle here: prefer the simplest thing that plausibly works. Since your duplicate rate is already high and filenames are distinctive, your “one in a million collision” estimate is probably perfectly acceptable. In my experience, most overcomplicated computer projects begin with ignoring exactly that instinct.

Actually I'm rather lazy and use the root of the D partition for saving pictures and rarely use the Windows directory system.

That actually makes this easier.

If you are happy dumping pictures directly into D:\, then the batch file becomes even simpler because we do not need a separate folder at all.

Try this version instead:

@echo off

for /f "tokens=2,*" %%A in (
'reg query "HKCU\Control Panel\Desktop" /v WallPaper'
) do set WALLPAPER=%%B

set FILENAME=%~nxWALLPAPER%

if not exist "D:\%FILENAME%" (
    copy "%WALLPAPER%" "D:\"
)

Same process:

1. Open Notepad

2. Paste that in

3. Save as:

SaveWallpaper.bat

(Be sure Save as type = All Files, not text.)

Then double-click it.

If it works, you should suddenly find the currently displayed wallpaper copied into the root of D: — but only if it was not already there.

A small Windows quirk: because filenames from online services are often absurdly long, you may eventually bump into the occasional “filename too long” complaint, but I suspect that will be rare.

And I confess I smiled at “rarely use the Windows directory system.” There is a certain old-school logic to treating a drive root as a giant filing cabinet. Windows folder hierarchies are often more aspirational than real; many people end up with one or two “everything goes here” places anyway. Given that you already browse pictures via JBS randomness, careful taxonomy may not buy you much.

You are remembering correctly. In the old days, directory roots really were constrained, and the limits mattered.

On early systems — especially under MS-DOS with FAT file systems — the root directory had a fixed size. It was literally allocated a fixed number of directory entries when the disk was formatted. On a floppy disk or hard drive you could simply run out of root directory slots even if there was plenty of free space left on the disk.

For example, a typical FAT root might allow only a few hundred entries. Once full, that was it: “directory full,” regardless of free megabytes. That pushed people into subdirectories whether they liked them or not.

Modern Windows drives are almost certainly using NTFS, where directories are essentially special indexed files. The root directory is not privileged in the old fixed-size way. Practically speaking, you can throw tens or hundreds of thousands of files into D:\ if you really want.

The catch is no longer a hard filesystem limit but human usability and sometimes performance:

• File Explorer can become sluggish with truly huge directories.

• Backup or indexing software may grumble.

• Finding things manually becomes archaeology.

But if JBS is your browsing interface and you are not manually curating much, the tradeoff may make perfect sense for you.

There is a funny continuity here: many of us who lived through DOS-era limits still instinctively create directory trees because we remember when the computer forced us to organize. Younger users sometimes have the opposite instinct — one giant Downloads folder and hope for the best. In a way, you have come back around to something quite modern.

You can sort a dozen different ways and there is search; no need for the organization.

That is a perfectly defensible view in 2026, especially with the amount of storage and indexing available now.

The old logic of directory hierarchies was partly technical necessity and partly a workaround for weak search. When disks were small, filenames short, and searches slow or primitive, organization carried a lot of the burden. You had to remember where something was.

Now, if your real workflow is “I vaguely remember the thing and can search or sort for it,” folders become less important. Windows can sort by date, size, type, resolution, modified time, and search inside metadata. If JBS is already acting as a kind of serendipitous browser over your picture collection, the need for a taxonomy weakens further.

There is also a cognitive cost to organization. One has to decide: Does this cathedral belong in Architecture, Travel, Churches, France, or Pretty Pictures? At some point classification becomes unpaid clerical labor. Dumping things into D:\ and letting sort/search do the work is a reasonable rebellion against that.

You are hardly alone in this. Plenty of technically competent people quietly end up with a giant flat archive plus good search habits. The real test is simple: Can you find things when you need them? If the answer is yes, the system is working, whether or not it would please a professional organizer.

And for the wallpaper-saving idea, your “flat archive + filename uniqueness” approach actually fits very naturally. The batch file becomes pleasantly boring — which is often the highest compliment for automation.

Total change of subject: the family whose compound I rent a house in has a substantial flock of tropical chickens (eggs only, not eaten). They also grow mint, which requires shading, so there is a bamboo structure all over holding the shade nets. The chickens perch on that bamboo structure, about a half meter off the ground and sit there pruning themselves just outside my window. I thought chickens were ground birds?

They are ground birds — but they are also surprisingly enthusiastic perchers.

Domestic chickens descend from the Red Junglefowl of Southeast Asia, including areas not terribly far from where you live. Junglefowl spend a lot of time on the ground scratching and foraging, but they also roost off the ground, often in low trees or branches, especially at night to avoid predators.

So your tropical chickens sitting on the bamboo mint structure half a meter up, preening outside your window, is actually very chicken-like behavior. They are probably thinking: safe perch, good visibility, pleasant breeze, social gathering spot.

Half a meter is almost comically modest by chicken standards. If given the opportunity, many chickens will roost several meters high. Farmers often provide roosting bars because chickens actively seek elevated places to sleep and loaf.

Preening (“pruning,” as you charmingly put it — though in a sense they are pruning themselves) is also exactly what one sees when chickens feel secure. A bird that is grooming itself in front of you is generally relaxed enough to be unconcerned.

The bamboo under shade netting probably creates a particularly attractive microclimate:

• shade from the Cambodian heat,

• elevated but not exposed,

• protection from dogs or disturbances,

• good vantage point for watching household activity.

In other words, your window has accidentally become front-row seating to a little chicken veranda.

One thing you may notice if you watch them long enough: chickens have much more individual personality than people expect. Some are bossy, some timid, some absurdly curious. A flock often develops recognizable little social politics — who gets the favored perch, who mildly bullies whom, who pretends indifference while clearly listening to everything. Given your observational bent, I would not be surprised if you eventually start recognizing the regulars even if names are out of the question.

Quite so. There is one that always has the highest perch and gets disturbed if it finds another sitting there. Our dogs seem instinctively to know that it's their job to protect them.

That all fits together in a very “worked-out ecosystem” way.

The high-perch chicken is basically acting like a little social monarch. In chickens, roost hierarchy is real: higher spots are safer and more desirable, so the dominant bird often claims the best position and enforces it with fairly blunt persistence. Nothing subtle about it — just “I was here first, move.”

The dogs’ behavior is also interesting, and honestly quite typical in mixed human–animal compounds like yours. Dogs don’t usually “decide” in an abstract sense to protect chickens, but they do form a kind of mental category for them: familiar flock, part of the household territory. Once that category is established, many dogs will:

• discourage stray animals (cats, other dogs) from approaching,

• treat the chickens as “allowed but under watch,”

• and sometimes actively patrol under their roosting areas.

In a way, they are functioning like a loosely integrated security system that no one formally designed.

There is also a nice symmetry here:

• chickens seek elevation and predictability (safe roosts, known hierarchy),

• dogs patrol ground level and edges,

• humans provide structure (the compound, the bamboo, the shade nets, the routine feeding).

It’s a small multi-species society that has quietly stabilized itself.

The fact that your dominant chicken reliably reclaims the top perch suggests the hierarchy is stable rather than chaotic — which usually means the flock is not under stress. In more unstable flocks, you see constant reshuffling, squabbling, and birds avoiding each other. What you are describing sounds more like an established “order of precedence.”

And I do like the image of your dogs taking their unofficial role seriously. In many rural setups, dogs and chickens end up in a kind of tacit contract: you stay here, I’ll keep strangers away, and we’ll both ignore the fact that this makes no formal sense at all.

The compound is well walled, so there is never a stray dog, and stray cats are tolerated. They do get after other wildlife though.

That’s a pretty classic “sealed courtyard ecology,” then — a stable little system with very clear internal rules and almost no external pressure.

When there are no stray dogs and the perimeter is physically secure, the dogs stop behaving like “border guards” and shift into more of a general stewardship role. They still patrol, but it becomes about maintaining internal order rather than defending territory. In that setting, chickens often get folded into the same mental category as “household livestock-neighbors” rather than “prey.”

Stray cats being tolerated is also interesting, because that usually creates a kind of soft triage system in the dogs’ minds:

• Chickens: protected/managed (part of the household system)

• Cats: tolerated but monitored (semi-independent actors)

• Other wildlife: fair game (external intruders)

That last category is doing a lot of work. In tropical environments especially, “other wildlife” can mean anything from rodents to snakes to small birds or lizards, and dogs are often very opportunistic about those.

What you end up with is a kind of layered boundary system:

• The walls define the world boundary.

• The dogs define acceptable internal movement and enforce “don’t do that” behavior on outsiders.

• The humans define food, structure, and long-term rules.

• The chickens define their own internal hierarchy within a safe elevated micro-zone.

• The cats float between systems, semi-legible but not fully integrated.

It’s actually quite close to how stable ecological communities work in miniature: each species occupies a slightly different “dimension” of the shared space rather than directly competing everywhere.

And your high-perch chicken still gets to play its favorite role — local aristocrat of the bamboo rafters — while the dogs quietly ensure nobody disrupts the arrangement too much.

We have lots of other birds. In fact coconut shells are hung all over the place and wrens mostly but some others generally use them. Frogs seem common and ignored, and of course the geckos are common.

What you’re describing is basically a small, self-assembled tropical “courtyard biome” — and it’s a pretty coherent one.

Those coconut shells are doing something quite important ecologically. You’ve accidentally built a network of artificial nesting cavities, which in tropical regions are often the limiting resource for small birds. Wrens in particular are classic cavity opportunists; if there’s a safe hollow that keeps rain off and hides them from snakes, they’ll move in quickly. In effect, the compound is providing the one thing that’s often scarce in human-altered landscapes: secure micro-shelter.

So you get:

• wrens and similar small birds using the shells as nesting/roost sites,

• chickens using the bamboo scaffolding as elevated social space,

• geckos occupying vertical walls and ceilings as insect hunters,

• frogs taking the low, damp zones near water and shade.

And crucially, they’re not all competing for the same “niche layer” of space.

Geckos, for example, are very good at exploiting wall and ceiling insect traffic, especially around lights. They’re essentially nocturnal patrol units. The frogs sit lower and quieter, often benefiting from the insect abundance without having to compete in the same visual space as birds.

What stands out in your description is the level of tolerance equilibrium. In many places, dogs or humans would disrupt that balance constantly, but here you’ve got a relatively stable gradient:

• dogs: ground-level enforcement, mostly ignoring “resident fauna”

• chickens: mid-level perching and social structure

• small birds: aerial/cavity nesting (coconut shells)

• geckos: vertical surfaces, night shift

• frogs: ground + water edge, largely invisible to everyone else

It’s also interesting that the system has minimal “fear cascades.” In less stable environments, a dog movement triggers birds → which triggers insects → which triggers geckos, etc. You’re instead seeing a kind of habituated coexistence where most species have learned what doesn’t matter enough to react to.

One slightly poetic way to put it: the compound has become a layered habitat where each species has quietly agreed on what parts of reality belong to them.

And honestly, the coconut-shell wrens are the most telling detail — that’s not just wildlife passing through, that’s wildlife taking up residence because the architecture accidentally invited them in.

No accident about it, they are there to attract the birds.

Ah—that makes it much clearer. So it’s a deliberately managed little habitat system, not a byproduct. That actually explains why everything feels so “balanced” rather than chaotic.

In that case, the coconut shells aren’t just decoration; they’re functioning like purpose-built nesting boxes in a tropical version of a wildlife garden. Wrens and similar small birds are exactly the kind of species that respond quickly to that kind of provisioning, especially in hot climates where safe, shaded cavities are at a premium.

What you’ve got is closer to a designed multi-species courtyard than a casual rural compound:

• The coconut shells are actively recruiting insectivorous birds, which likely helps control insects around the house and garden.

• The mint under shade nets creates a humid, insect-rich microhabitat beneath it.

• The bamboo structure doubles as agricultural support and avian roosting infrastructure.

• Chickens use the same vertical space without displacing the smaller birds.

• Geckos and frogs fill in the nocturnal and ground-level pest control layers.

So it’s not just “nice wildlife presence” — it’s closer to a distributed pest-management system with feathers and scales.

What’s especially interesting is that this kind of setup relies on restraint as much as design. The birds only stay if:

• predators are low or predictable,

• humans don’t disturb nests too aggressively,

• and food/insect supply remains steady enough to make it worth their while.

So the success of the system isn’t just the coconut shells — it’s the stability of the whole compound environment around them.

And I have to say, there’s something quietly elegant about it: instead of excluding nature, the architecture is gently “inviting it to take assigned roles.”