Most screensavers either treat the whole desktop as one big rectangle or run a separate copy on each screen. Bounce treats your monitor layout as one connected space. The ball (or several balls, or a logo) moves freely from one screen to the next and bounces off the edges where monitors of different sizes don’t line up, including the inside corners those mismatched edges create.

• Source Code: on github

Features

• Uses your real arrangement from Settings → System → Display (monitors must be set to Extend)
• Multiple balls, or a custom image in place of the ball
• Adjustable color, size, and speed
• Optional flash when a ball hits a corner dead-on
• Optional fading trail, or a “Forever” trail that never fades. Leave the Forever trail running for a while and it should eventually paint over every screen, which makes it a handy way to check that the ball can reach every part of your layout.
• Works with mixed-DPI monitors
• Can be installed without admin rights

How it works

The play area is the union of your monitors

MonitorRegion builds a GDI+ Region from the union of every Screen.Bounds. That gives the exact shape of your desktop, notches and all.

Monitors that look snapped together in Display Settings can still have a small gap between their actual pixel bounds. That happens with mixed DPI, or just from imprecise dragging. Without a fix, the ball would treat that gap as a solid wall. So any two monitors that face each other across a small gap get a “bridge” rectangle filling it:

// a's right edge facing b's left edge.
int horizontalGap = b.Left - a.Right;
if (horizontalGap > 0 && horizontalGap <= MaxBridgeableGap)
{
    int top = Math.Max(a.Top, b.Top);
    int bottom = Math.Min(a.Bottom, b.Bottom);
    if (bottom > top)
        bridges.Add(Rectangle.FromLTRB(a.Right, top, b.Left, bottom));
}

Containment checks run every tick, so they’re kept cheap. Most of the time the ball is fully inside a single monitor, and plain rectangle math answers the question. The slower GDI+ region test only runs when the ball is straddling a seam.

Collision tests each axis on its own

Each tick, the ball tests three possible moves: X only, Y only, and both together. Comparing the results tells it what kind of edge it ran into:

bool xOk    = _region.Contains(new RectangleF(nx, Position.Y, Size, Size));
bool yOk    = _region.Contains(new RectangleF(Position.X, ny, Size, Size));
bool bothOk = _region.Contains(new RectangleF(nx, ny, Size, Size));

• Both OK: move diagonally as normal.
• Only one axis OK: it hit a flat edge, so slide along it and reverse the other direction.
• Each axis OK alone, but not together: this is the interesting case. The diagonal move would cut across the notch where two monitors of different sizes meet, through space that isn’t on any screen. The ball slides along whichever axis it’s moving faster on and bounces off the other.
• Neither OK: a dead-on corner hit. Both directions reverse (and the corner flash fires, if it’s turned on).

One window per monitor

Windows applies a single DPI scale to each top-level window. With one giant window stretched across monitors that have different DPI settings, Windows stretches the parts that aren’t on the window’s “home” monitor, which made the ball look squashed. So Bounce opens one borderless, topmost window per monitor. A single shared simulation drives all of them, and each window draws its own part of the desktop at native resolution.

Installing

Every build also produces a Bounce.scr. Right-click it and choose Install. Or, if you don’t have admin rights, run Install-Screensaver.ps1 from the repo. It points the per-user registry setting at the build output instead of copying anything into System32. The repo README also covers publishing a self-contained build for machines without the .NET 10 runtime.

I wrote three small Node.js services for mine: a scheduler that posts a morning briefing, plus Slack and Discord bots that let other people post messages to it.

• Scheduler Source Code on github
• Slack Integration Source Code on github
• Discord Integration Source Code on github

All three use the same setup: a Vestaboard API token in a .env file, then a single node index.js command, or a Docker container with --restart unless-stopped so it keeps running.

Morning Briefing (Scheduler)

Every morning at 6:30 the scheduler posts the date, weather, sunrise and sunset, and the day’s tides (I live in a beach town):

     MONDAY JUNE 22ND
  PARTLY CLOUDY 72°/58°
 RISE 5:12AM SET 8:34PM
HIGH               LOW
10:23AM        3:45PM
 4:12PM        9:58PM

Both data sources are free and need no API key. Weather comes from Open-Meteo, and tides come from NOAA Tides & Currents. The tide station, location, time zone, and schedule are all set in the .env file, and they default to Cohasset Harbor. The scheduler uses croner for the timing:

new Cron(MORNING_CRON, { timezone: TIMEZONE }, runMorningBriefing);

Both APIs are called at the same time, and their results are combined into the grid:

const [weather, tides] = await Promise.all([getCurrentWeather(), getTodayTides()]);
const grid = buildMorningGrid(weather, tides);
await postGridToVestaboard(grid);

Pass --now to post a briefing right away, which is handy for testing.

Laying out the board

Plain text sent to the Vestaboard API gets laid out by Vestaboard, so you don’t control where anything goes. To line up columns like the tide table, you send a 6×22 array of character codes instead. Each character on the board has a numeric code:

const CHAR_CODES = {
  ' ':  0,
  A:1,  B:2,  C:3,  /* ... */  Z:26,
  '1':27, '2':28, /* ... */  '0':36,
  '!':37, '@':38, /* ... */  '°':62,
};

function textRow(text, width = 22) {
  const codes = [...text.slice(0, width)].map(charCode);
  while (codes.length < width) codes.push(BLANK);
  return codes;
}

From there, each row is built with ordinary string padding. Here, high tide times are left-aligned and low tide times are right-aligned:

function tideTimeRow(high, low) {
  const h = (high ? formatTideTime(high.time) : '').padEnd(13).slice(0, 13);
  const l = (low  ? formatTideTime(low.time)  : '').padStart(9).slice(0, 9);
  return textRow(h + l);
}

Open-Meteo reports conditions as WMO weather codes. These get mapped to short labels like PARTLY CLOUDY or TSTORM+HAIL, so the conditions and temperatures fit on one 22-character line.

Slack

The Slack app adds two slash commands:

• /vesta [message] posts any text to the board
• /tides posts the day’s high and low tides as a grid, built the same way as the scheduler’s

It uses Bolt in Socket Mode, which means it connects out to Slack. There’s no public URL to host and nothing to open on the firewall, so it can run on any machine at home.

To keep the board from getting spammed, each user can post once per minute. If someone tries again too soon, they get a private reply only they can see:

const lastPost = lastPostTime.get(userId);
if (lastPost && now - lastPost < RATE_LIMIT_MS) {
  const secondsLeft = Math.ceil((RATE_LIMIT_MS - (now - lastPost)) / 1000);
  await respond({
    response_type: 'ephemeral',
    text: `⏳ You can only post once per minute. Please wait ${secondsLeft} more second${secondsLeft === 1 ? '' : 's'}.`,
  });
  return;
}

When a post works, the bot replies in the channel so everyone can see who posted what.

Discord

The Discord bot does the same thing for a Discord server with a /vesta slash command and the same one-post-per-minute limit. It registers the slash command itself when it starts up. Because the call to the Vestaboard API can take a moment, the bot defers its reply first. That tells Discord the bot is working on it, so the interaction doesn’t time out:

await interaction.deferReply();
// ... post to the Vestaboard ...
await interaction.editReply(`Posted to the Vestaboard: **${text}**`);

• thread safety
• enumeration (IEnumerable<T>, so LINQ just works)
• point-in-time snapshots
• cleanup that doesn’t block readers or writers

MemoryCache is keyed and heavier than I wanted. ConcurrentBag has no concept of time. Nothing I found covered all four, so I wrote my own and published it as an open source package.

• Source Code: on github
• Nuget Package: on nuget

Usage

dotnet add package TemporalBag

Create a bag with a default time-to-live, add items, and enumerate. Expired items are never returned.

using TemporalBag.Core;

// Items expire after 30 seconds; background cleanup runs every 10 seconds (default).
using var bag = new TemporalBag<string>(maxAge: TimeSpan.FromSeconds(30));

bag.Add("hello");
bag.Add("short-lived", TimeSpan.FromSeconds(5));  // per-item TTL override
bag.Add("long-lived",  TimeSpan.FromHours(1));

foreach (var item in bag)
    Console.WriteLine(item);

var matches = bag.Where(x => x.StartsWith("long")).ToList();
bool exists = bag.Contains("hello");
int live    = bag.Count;

AsLive() returns each item along with how much time it has left:

foreach (var (value, remaining) in bag.AsLive())
    Console.WriteLine($"{value} expires in {remaining.TotalSeconds:F1}s");

How it works

Each item stores its own expiration

Every value is wrapped with a deadline measured in Stopwatch ticks. Stopwatch uses a monotonic clock, so changes to the system clock (NTP sync, DST) can’t make items expire early or late.

private class TtlValue(TValue value, TimeSpan ttl)
{
    public TValue Value { get; } = value;
    private readonly long _tickCountWhenToKill =
        Stopwatch.GetTimestamp() + (long)(ttl.TotalSeconds * Stopwatch.Frequency);

    public bool IsExpired(long currTickCount) => currTickCount > _tickCountWhenToKill;
}

Reads filter out expired items

Enumeration, Count, and Contains all read the clock once at the start and skip anything past its deadline. Every item in one pass is checked against the same instant, so you get a consistent snapshot. Because of that, reads are always correct whether or not cleanup has run yet.

private IEnumerator<TValue> GetEnumeratorCore()
{
    var currTime = Stopwatch.GetTimestamp();
    foreach (var item in _list)
    {
        if (!item.IsExpired(currTime))
            yield return item.Value;
    }
}

Cleanup swaps in a new bag

The items live in a ConcurrentBag. A background timer periodically compacts it. Instead of removing items one at a time, it atomically swaps in an empty bag and copies over only the items that are still live. Any Add() that happens during cleanup goes straight into the new bag, so nothing is lost and writers never wait on a lock.

private void DoCleanUp()
{
    var currTime = Stopwatch.GetTimestamp();
    var oldList = Interlocked.Exchange(ref _list, new ConcurrentBag<TtlValue>());
    foreach (var item in oldList)
    {
        if (!item.IsExpired(currTime))
            _list.Add(item);
    }
}

Clear() uses the same swap, so emptying the bag is a single atomic operation no matter how many items it holds.

A SemaphoreSlim makes sure only one cleanup runs at a time. A manual CleanUp() call uses Wait(0), so if a cleanup is already running it returns false right away instead of waiting:

public bool CleanUp()
{
    if (_cleanupLock.Wait(0))
    {
        try { DoCleanUp(); return true; }
        finally { _cleanupLock.Release(); }
    }
    return false;
}

The bag implements IDisposable to stop the background timer, so use it in a using block or dispose it when you’re done.

Targets

netstandard2.0, net8.0, and net10.0. MIT licensed.

Source Code: on github Running Example: on github pages