A word on the version numbers first, because all three Mac apps jumped to 0.50 within three days — Lancetta from 0.17, FinderGit from 0.47, Netfox from 0.29. There are no releases in between to go looking for; the number says how much changed. Part of what changed is shared: FinderGit’s Agents page and Lancetta’s Maintenance pane are the same dashboard, and the cards that now open in place in all three apps are the same deck, written once in a package the apps share, AgentsKit. So some fixes now arrive everywhere at once: on the 13th, cards that replayed their whole entrance on every window resize stopped doing it in FinderGit and Netfox. The same day, the Discord logo in all three About windows, drawn with its right side missing, was made whole, that one by hand in each app. The oldest shared bug had nothing to do with that package: on the 2nd, all three apps fixed a Check for updates on launch switch whose check had never actually run — it asked while the updater was still starting up, and was quietly turned away. If you were on an older version, you heard about that fix the old way.

Lancetta

It tells you what to do, not just what is left (0.50.0). A quota monitor that shows 82% has done its part and left you the hard one: deciding whether to slow down, switch model or carry on. 0.50.0 puts suggestions at the top of the panel, worked out on your Mac from Lancetta’s own readings — the account’s reports, how fast you are going, when each window resets, any free reset you hold, the effort you have set. No model is asked, and every suggestion shows the readings it rests on. When you are heading for the wall it says when, and what to do about it: At this pace Claude stops in 51m, then waits 1h18m for its reset — lower the effort, give routine work to a lighter model, or move the next tasks to the agent that still has room. It works the other way too, because a low number on the menu bar can be capacity you are wasting rather than good news: Codex has room: 88% of this 5-hour window is unused, and it resets in 39m. An urgent suggestion arrives once as a notification, and when nothing needs changing, it says so, in green.

What your agents read before you type (0.50.0 → 0.54.0). The other half of 0.50.0 is a Maintenance pane. Claude Code and Codex read a stack of files at the start of every session — CLAUDE.md, AGENTS.md, rules, skills, memory — and nothing tells you when that stack has grown past the size at which Claude Code warns. Maintenance measures each repository’s start against that size and runs twenty checks. Five kinds of fix are applied whole after a line-by-line preview; the rest open Claude Code in plan mode with the prompt already written. 0.51.0 hands Codex the files that belong to it and makes both agents propose before they change anything: Codex cannot be started in its Plan mode from outside its own window, so it is told to propose and wait, and its sandbox may write only in the repository and the file’s folder. 0.53.0 adds Fix All — one preview of every fix that needs no choosing — and a check for the programs your setup calls that cannot start: a hook, a status line or an MCP server pointing at a program that is missing or cannot run, a path with a space and no quotes, a variable nobody fills. Three kinds it fixes itself, each offered only when the program would then start: quotes round the path, execute permission for a script, and the variable written the way Claude Code fills it in. And 0.54.0 noticed that Maintenance had only ever asked Claude Code where you work, so a repository you only open with Codex was never checked; it now reads Codex’s last thirty days too. FinderGit has the same page under another name — more on that below.

The rate, not the average (0.15.0, 0.16.0). The line under each bar used to project the window’s average to its reset — at this pace 96% by reset — and late in a week that average spreads one afternoon of work across idle nights, so it mostly repeated the bar. The question you actually have is if I keep going like this, when do I have to stop?, and since 0.15.0 the line answers it in amber, from the last hour or so of readings: at this rate you run out in 2h00m. It speaks only when you would run out before the reset and within a few hours, and only for the window that would stop you first. 0.16.0 was meant to go further, with a forecast each morning of how far into the day the 5-hour window would carry you. It did not ship: over two and a half weeks of readings, none of six kinds of morning forecast beat a single fixed number chosen afterwards, and neither of the two days Codex ran out was foreseen — the numbers are on the roadmap. What shipped instead needs no forecast: working hours, off by default, so the run-out line goes quiet when you would only run out after your day ends and notifications outside your hours go silently to Notification Centre; and a Usage card with each day’s fullest 5-hour window, Codex and Claude side by side.

Seven languages (0.14.0 → 0.17.0). Lancetta follows your Mac’s language now — English, Italian, French, German, Spanish, Portuguese and Dutch — with nothing to set up. Much of what it says is a sentence about time, at this pace it is spent by tomorrow afternoon, and it does not reset until Thursday afternoon, and those had been assembled a phrase at a time in English word order; they are translated as whole sentences now, with weekdays and dates in the sentence’s own language. 0.14.0 also shipped a bug no translation explains: a window card, usually Codex’s, could show its title and labels upside down while its numbers looked fine, until 0.14.1 the next day. 0.14.2 translated the Processes rows the first pass had missed, and 0.17.0 gave Dutch two different words for Alerts and Notifications, which had been sharing one.

Reclaim, and a folder with a double dash in its name (0.14.1, 0.16.1). Reclaim stops agent processes that have been left orphaned, and it could stop one that was still working. Lancetta read a process tree’s folder from the process list, which joins arguments with spaces and quotes nothing, so a folder with -- in its name came back cut short, as a path that does not exist, and the tree looked abandoned. 0.14.1 had added a second check at the moment you confirm — and that check read the folder the same way. Since 0.16.1 the arguments come from macOS one at a time, and a tree Lancetta cannot read is never treated as gone. Two smaller confessions from the same fortnight: the pin on the panel was supposed to let you move it off the menu bar, and the panel never moved (0.15.2); and signing Codex in to another account could carry the old account’s free resets over: shown for the new one (0.14.1), or announced as a fresh grant if Lancetta was closed at the time (0.16.1).

And the rest. A click anywhere on an agent’s card opens the window (0.15.1). Notification settings had lived in three places — if you wanted to know why a notification had or had not arrived, you had three places to look — and now have one pane of their own (0.17.0). The panel’s footer gave way to a gear menu, with Refresh Now on a right-click of the menu-bar item (0.51.0), and About went to two columns, like FinderGit’s and Netfox’s (0.52.0, 0.52.1). Fifteen releases, 0.14.0 → 0.54.0; free, universal, signed and notarised, on macOS 15 or later.

https://lancetta.app

FinderGit

What your coding agents read before you type (0.50.0, 0.51.0). Claude Code, Codex, Cursor, Copilot and Gemini CLI each read a stack of files at the start of every session, and every session pays for all of it again, before your first word — with nothing to tell you when the stack has grown too big, or when part of it is never read at all. The new Agents page scans those files across your repositories, the folders above them and your home folder, shows what each start costs, and runs checks that each say why they matter: twenty in 0.50.0, twenty-two by 0.51.0. When a finding has exactly one right answer, the fix is shown in full and applied whole or not at all; when it needs judgement, Fix with Claude Code opens it in plan mode, or Fix with Codex, with the prompt already written. 0.51.0 gathers every fix that needs no choosing into one Fix All preview — every file and every line — before anything is written. It is the same dashboard as Lancetta’s Maintenance pane, and Lancetta 0.53.0 shipped the same changes the same day.

Your disk space back (0.44.0, 0.50.0). Disks fill up with folders you never wrote — node_modules, .next, DerivedData, the npm, Yarn, Homebrew and Go caches. On my own Mac the first scan found about 30 GB. The new Cleaning page counts them up in eight cards and pre-ticks only what is safe: not in use and, inside a project, untouched for a month; everything else carries a badge saying why it was left alone. Inside a repository a folder qualifies only if the repository’s own .gitignore ignores it and it sits beside its project file — nothing Git tracks, no symlinks, nothing inside .git — and every folder is checked again just before it is deleted. Deleted, not moved to the Trash: the space is the point. The size shown is what deleting that one folder frees, and 0.50.0 stopped quietly leaving out the two kinds of folder where that answer is not simple: node_modules that live in a shared clone store, now listed with a Shared badge and what deleting them would really free, and build folders committed to git, listed with an In git badge and never ticked or cleaned.

The Overview tab, now a dashboard you can take with you (0.45.0, 0.46.0). The per-repository Overview was the quietest corner of FinderGit, and nearly empty for any repository that did not live on GitHub. It is a dashboard now: a pulse — Active, Steady, Quiet or Dormant, from the newest commit — when history began, the latest tag and the commits waiting on top of it, a headline from the GitHub description or the README’s first sentence, twelve tiles that each open their tab, a year of commits with its streaks, a weekday-by-hour chart, languages, project hygiene files, recent commits and releases, contributors. Almost all of it is read from the repository itself, so a local-only repository gets the whole thing. A dashboard is something you want to put in a pull request or a status update, and a window screenshot rarely does it justice, so 0.46.0 exports it — PNG, PDF or the clipboard — at full height and two columns wide whatever the size of your window, with the repository, branch and date across the top. And 0.45.1 fixed English footnotes that had been printing raw markup, ^[of 3 repository](inflect: true), instead of of 3 repositories.

Your GitHub profile on one card (0.52.0, 0.52.1). Some things you keep for yourself; a GitHub profile is made to be shown. The Account page now renders as one picture: ten figures, a year of contributions with the longest streak, best day and busiest weekday, your most-starred repositories and your languages. It comes in nine looks — Midnight, Aurora, Daylight, Upside Down, Hyperspace, Bridge, Nebula and two seasonal ones: Halloween is in the menu until 2 November, and Christmas arrives on 1 December and leaves after Epiphany. Save it as a PNG at twice its size or a one-page PDF, copy it or share it. Repository figures come from public repositories only, so a private repository’s name never reaches the picture. 0.52.1 adds a switch that draws the year as a line — each day the average of the week up to it, so you read a trend instead of a comb of spikes — and fixes the Account page’s own contribution graph, whose curves overshot and drew a negative count that never happened.

Zoom, pull to refresh, and a sidebar your way (0.41.0 → 0.47.0). Zoom now scales the whole content of the window, file browser to dashboards, from 75% to 300% like Safari, while the sidebar and toolbar stay put so the controls never move while you are reaching for them. On macOS 27 every list and the repository panel refresh with a pull, the way Mail does — and a pull never fetches, pulls or pushes; it reloads what you are looking at. Then 0.47.0, from a reader who wrote in with two small wishes: sidebar sections that collapse like Finder’s and rows you can hide, in a new Appearance pane. It also shows a detached HEAD plainly, and the buttons that must wait for a running pull or push now dim and say why in a tooltip — before, they looked ready and refused the click. Fourteen releases, 0.41.0 → 0.52.1, on macOS 15 or later; pull to refresh needs macOS 27.

https://findergit.app

WordPress: WP Bones and Scotty

When a plugin says nothing (WP Bones 3.0.0). A framework makes a choice every time a plugin leaves something out, and in 2.x those choices were the convenient ones. 3.0 makes them the safe ones. A page or menu that declares no capability is now for administrators, where any logged-in user could open it before; a REST route with no permission_callback refuses every request instead of being public; every non-GET request to an admin page needs a nonce. Migrations run once per site — on activation, or on the first request after the plugin’s version changes, however it got there — where 2.x ran every migration and every seeder again on each activation and dashboard update, with the old code still loaded; seed data is a migration now. Logs and compiled views move out of the plugin’s folder into wp-content/uploads/wpbones/. PHP stays 8.1+, and php bones migrate:to-v3 converts what it can and lists what it leaves to you.

The same day, for everyone staying on 2.x (2.1.1 → 2.1.3). Two of those defaults were security bugs, and they were fixed in 2.x first, in a form that breaks nothing. Pages from config/routes.php and pages/ have no menu entry, and any logged-in user — subscribers included — could open them, because the documented capability key was never read; it is read now, with read as the default (2.1.2). And the default logger was also writing a log file into a world-writable folder inside the plugin, which the web server serves, while compiled Blade views could be downloaded as source (2.1.3). If you have run an older 2.x, those log files are still there, and they have to be deleted by hand. 2.1.1, earlier that morning, fixed activation running before the plugin’s header had been read, which saved the plugin’s options under a row with no name. Plugins on ^2.x stay on 2.1.3 until they change their constraint.

Your stubs, and your tests (3.1.0, 3.2.0). The make:* generators read their templates from vendor/, so every composer update threw away whatever you had changed in them; they now look in the plugin’s own stubs/ first, and php bones stub:publish puts them there — with the catch that a published stub no longer follows the framework’s. And php bones deploy now leaves test suites out of the package: with --wp, Jest tests had been travelling to WordPress.org, and Scotty’s 2.2.0 package carried four such folders, removed by hand. If the package’s autoloader still requires a file the deploy left out, the deploy stops and names it, rather than shipping a plugin that fails on every request.

Nine add-on packages, read again for 3.0. On the 7th, Geolocalizer 2.0.0 moved its countries table from a seeder to migrations, because 3.0 runs no seeders; wptables 1.1.0 started requiring a nonce on bulk actions — its form is a GET, which 3.0’s check does not cover, so a link could trigger one; and two packages fixed fatal errors, one of them in the very calls its README documented. The 14 boilerplates moved with every framework release.

Scotty 2.2.1. Scotty is the maintenance plugin built on WP Bones. It now translates whole sentences, plurals included — 257 of 257 strings in Italian, Spanish, French, German and Brazilian Portuguese — and its duplicate lists are several times faster: 6.2 seconds down to 1.1 for post meta on 300,000 rows. The Database tools now reach only this site’s own tables, which matters on a shared database or a multisite network, and Optimize and Reset Auto Increment report an error instead of announcing success. Bannerize had nothing new this fortnight.

wpbones.com · Scotty on WordPress.org

Netfox

From reading Wi-Fi to joining it (0.29.0). Netfox could tell you your signal was weak or your channel crowded, and then leave you to fix it somewhere else. Now Join… opens a sheet that names the network you are about to leave and warns you when the new one is open; the password goes to macOS for that one join, and Netfox keeps nothing. When the verdict says your link has a problem, a network you already know that is at least ten decibels louder, and good in its own right, is offered with Switch… — and nothing is suggested while your Wi-Fi looks fine. The list works like Devices now: filter by band, known networks or networks with no password, and search by name, address, maker or security, so even a hidden network can be found by the maker of its access point. One honest limit: it asks for the password every time, even for a network your Mac knows, because it does not read the one macOS saved.

The green lock that said too much (0.29.1). 0.29.0 also learned about Enhanced Open — networks you join without a password that still encrypt what you send, which deserve a green lock while a plain open network gets a red one. But the check behind it said yes to every network without a password, so for a day every open network wore the green lock, and Join… told you your traffic would stay encrypted. On an open network, it does not. 0.29.1 calls a network Enhanced Open only when it really encrypts, and Join… warns that what you send over an open one can be read by anyone nearby. The same misreading made a plain WPA2 network list modes it does not offer — WPA Mixed, WPA2 Personal, WPA3 Transition — and it now reads WPA2 Personal. If you joined an open network thinking it was encrypted, look at System Settings → Wi-Fi → Known Networks: your Mac can rejoin a known network on its own, open ones included.

The numbers open (0.50.0). Netfox would tell you three devices were at risk and make you leave the page to find out which. On the Overview, the Risk, Devices and Alerts cards now open into a panel right underneath; every row opens its device, and a risky one lands on its Ports tab. The page opens on the most urgent card. On Security, the high, medium, low and untested counts are cards too, and low-risk devices finally have a list of their own. And closing the window no longer means looking away: it used to stop discovery, alerts, scheduled port scans and the metrics endpoint without a word, while the menu bar looked alive. Now they run until you quit. Smaller, in the same release: a USB Ethernet adapter on the driver built into macOS no longer gets a false below top speed warning, and This Mac no longer shows 127.0.0.1 as its address.

Fold what you do not read, and stay lean (0.51.0). Sections in the narrow panes fold with a click — a device’s details, the Link card, a Wi-Fi network’s details — and Netfox remembers the fold on every device and across restarts. A folded Wired or Wireless section shows an orange mark when it is hiding a warning, so folding never means not knowing. Each alert in the notch now says what happened: a new device, one that came back, a port that opened. And a cost 0.50.0 had not paid: an app that now runs for days with its window closed had in-memory lists that grew for as long as it ran. Alerts older than 90 days leave them now, and the signal history of a Wi-Fi network unseen for ten minutes is let go. Five releases, 0.28.1 → 0.51.0, on macOS 15.6 or later.

https://netfox.app

octoscope

Your last dashboard, at once (0.39.0). Every launch used to wait on GitHub — about ten seconds on my account — before showing anything. Now octoscope opens on the last dashboard it drew, with the footer saying so, cached 3h ago · refreshing…, and swaps in the live numbers quietly when they arrive: no flash, no star notification. Offline, the dashboard stays up as offline · retrying · cached 3h ago. That fixed a bug as old as the project: since 0.1.0, any failed refresh replaced the whole dashboard with an error screen, so the footer’s offline message had never once been visible. The cache is a file only you can read, under a week old, written by the same version for the same token and account; it is never used with --public-only, --json, --plain or --scan, and dashboard_cache = false turns it off and deletes it. The first launch after upgrading still waits.

Is anything of mine compromised? (0.38.0). After every supply-chain worm the question is the same, and the scan answered it one repository at a time. octoscope --scan sweeps the default branch of every repository you own, plus your watch_repos — about 17 seconds for 95 repositories — and a repository it cannot read is reported as not scanned, with the reason, never counted as clean. Its --json output is a versioned contract. The scan was also wrong in a way worth owning: it called unsigned commits by github-actions[bot] forged, and flagged my own Homebrew tap and website. It now reads the recent changes to the files that can actually run code — hooks, tasks, package manifests, workflows. The repository view gained fourteen days of traffic and the most severe Dependabot alerts, with whether a fix exists, and a pull request that belongs to a stack now shows its layers.

What is waiting for you (0.37.0). The Inbox tab lived only in the dashboard, so a script had to call GitHub’s notifications API itself. --inbox adds up to 50 unread threads to --json and --plain, newest first, each with GitHub’s reason, the repository, the title and a link. As with --activity, a missing inbox key means you did not ask, [] means inbox zero, and a failed fetch fails the run. octoscope torvalds --json --inbox is refused, since it would print your notifications under someone else’s name, and a fine-grained token — which GitHub refuses for notifications — now gets an error naming the token you need instead of a bare 403. Before all that, 0.36.1 made the What’s new tab fit a 24-column terminal. Four releases, 0.36.1 → 0.39.0, also as the gh extension.

https://gfazioli.github.io/octoscope · brew upgrade gfazioli/tap/octoscope

glancecard

Your GitHub, as a card in your README (0.1.0, 0.2.0). glancecard is new, and this is its first appearance here. It draws daily SVG cards of your GitHub profile and of your repositories, for the READMEs you own: a repository card with its status, age and latest tag, thirty days of commits, twelve stat tiles, a year of activity with its streaks, the weekly rhythm, languages, the latest commits and releases and the contributors; a profile card with followers, stars, pull requests, issues, commits, a year of contributions and your most-starred repositories. The cards are drawn by a GitHub Action in your own repository, with the token every run already has, and committed as plain files — no server, no third-party service, no dependencies — and setting it up is one paste into Claude Code or Codex. It is careful by default: a private repository is refused unless you allow it, a history longer than it was told to read is stated on the card instead of being silently undercounted, and on a pull request the cards are rendered but never committed. 0.1.0 and 0.2.0 went out on the 14th, the second with nine looks taken from FinderGit’s Profile Card, the seasonal ones included. By the next day it was drawing the card under the title of sixty-one of my public repositories, and of every active public WP Bones one.

A shade is a range (0.3.0). GitHub’s green squares tell you which days you worked, not how much: a shade is a range. Since 0.3.0 the year is a line of daily counts over a value axis, on both cards, and calendar: grid brings the squares back. The profile card now asks GitHub for each day’s count, so the days in the chart add up to the total printed above it. There is no moving v0 tag, on purpose: you upgrade by pinning gfazioli/glancecard@v0.3.0, and Dependabot can open that pull request for you.

gfazioli.github.io/glancecard · GitHub Marketplace

Mantine extensions

Mantine 9.7 shipped two components of its own that overlap two of these — a Tour and a JSON viewer — and the answer was to read core point by point and close what could be closed. Five components with a core counterpart now carry a comparison table in their docs, and three of them — JSON Tree, Marquee and Window — have no row left that only core can do.

JSON Tree learned to edit (3.5.0 → 3.7.0). Diff highlighting, long arrays in collapsible groups, long strings behind show more, type badges and sorted keys (3.5.0); then renaming, adding, removing and reordering, from the mouse or the keyboard — key renaming had been called deliberately out of scope in the 3.4.0 notes (3.6.0); then every built-in string translatable, and an accessible name on every icon button, where before none had one (3.7.0). On the way, an empty object stopped rendering as [object Object] and an empty array stopped rendering as nothing at all.

Window, on a phone (3.3.0, 3.4.0). A headless useDragResize hook — Window itself is now built on it — an axis lock and keyboard resizing came first. Then a report on the Mantine Extensions Discord from a Samsung S24 Ultra in Firefox and an iPhone 16 Pro Max in Safari: windows left their container when the phone rotated, a window followed the first finger on the screen rather than its own, and the page grew sideways. Windows now return inside their bounds after a rotation or a resize, and a swipe scrolls the content instead of dragging the window. Measured: windows left outside after a rotation went from 30 to 0, and on a 390-pixel screen the page went from 811 pixels wide to 445.

Marquee 5.0.0, a major. Built to drop in where core’s Marquee goes: gap now uses the theme’s spacing scale (a marquee that never set it stays at 16 pixels), pauseOnHover also pauses on keyboard focus, and fadeEdgeColor works — it had been accepted and ignored. The tests went from 28 to 68.

Onboarding Tour 4.1.0. Arrow keys, Escape to skip, focus that moves into each step and back at the end, and a step whose target is missing is centred — before, the overlay appeared and the popover did not. It also stopped remounting your components on every step, which had been throwing away form state and focus.

And the unglamorous half. Text Animate 4.0.13: component="h1" with by="character" rendered one h1 per character, so the extensions site’s All Extensions title was fourteen headings — a crawler check found it. And four dependency-only patches in the 9.7.0 sweep went out carrying an older release’s notes, picked up from a leftover changelog file: JSON Tree 3.4.4’s notes describe a feature from August, and the release itself is only the version bump. The sweeps — Mantine 9.7.0 on the 5th, 9.7.1 on the 9th, 9.7.2 on the 13th — were one patch per component, 78 in all, nothing for you to do; the extensions site and the two documentation templates moved with them, and the site’s component pages now open with their video, where there is one, and a link to the component’s own docs, ahead of the live demos.

mantine-extensions.vercel.app

And the rest

There is an Undolog Discord now, opened on 8 October as the home of FinderGit, Netfox, Lancetta and octoscope, and linked from every About window: discord.gg/rdWu5yFCR6. gfazioli.github.io carries it in the header, the hero and the footer, gained a legal notice and a privacy page, and stopped turning white: the Mantine extensions’ docs live at the same address and stored their light-or-dark choice under the same key, so picking light on an extension’s page turned the portfolio light until you cleared storage. Scotty 2.2.1 fixed a cousin of that bug, a colour scheme saved under the same shared key on every visit. No Raycast extension and no React library shipped this fortnight; the last release of each still stands.

Undolog — open source studio. Every project in one place: gfazioli.github.io · this newsletter lives at undolog.com

• FinderGit — a Git-aware file browser for macOS · findergit.app

• Lancetta — a menu-bar monitor for the quotas of Codex and Claude Code · lancetta.app

• Netfox — a network monitor for macOS · netfox.app

• octoscope — a terminal dashboard for GitHub · gfazioli.github.io/octoscope

• glancecard — daily SVG cards of your GitHub profile and repositories, for your READMEs · gfazioli.github.io/glancecard

• WP Bones — a Laravel-style framework for WordPress plugins, with Bannerize and Scotty built on it · wpbones.com

• Mantine extensions — 26 components on npm · mantine-extensions.vercel.app

• Raycast extensions — for the Raycast launcher · raycast.com/Undolog

Netfox’s Wi-Fi tool puts a padlock beside every network: green and closed when the traffic is encrypted, red and open when it isn’t. Version 0.29.0 added a third case, Enhanced Open (OWE): a network you join without a password whose traffic is still encrypted. It deserves the green lock, and the join sheet tells you so.

A day after shipping it, I filtered the list to “No password” and saw two networks with a green closed padlock. One, by the look of its name, was a neighbour’s smart vacuum showing its setup hotspot. Its radio didn’t even do 802.11n, and it was supposedly speaking a protocol from 2018. system_profiler SPAirPortDataType agreed with my suspicion: Security: None. Netfox said Enhanced Open, Open.

The code looked right

This is the classifier as it shipped:

private static let enhancedOpenModes: [CWSecurity] = [.OWE, .oweTransition]

static func classifyAccess(for cwNetwork: CWNetwork) -> WiFiNetwork.Access {
    WiFiNetwork.Access.classify(
        open: cwNetwork.supportsSecurity(.none),
        enhancedOpen: enhancedOpenModes.contains { cwNetwork.supportsSecurity($0) },
        password: personalModes.contains { cwNetwork.supportsSecurity($0) },
        enterprise: enterpriseModes.contains { cwNetwork.supportsSecurity($0) }
    )
}

OWE has a transition mode: the access point runs an open network plus a hidden OWE one, and a client that speaks OWE quietly uses the encrypted side. So .oweTransition looked like exactly the flag to check. The header documents it as “OWE Transition” and nothing more.

Asking CoreWLAN directly, with no access point and no permission

To see what the API really answers, I needed networks whose security I knew. I didn’t have an OWE access point, and on recent macOS an app without Location access gets scan results with the SSID, the BSSID and the raw information elements blanked out.

But CWNetwork keeps everything it parsed in a private dictionary, and supportsSecurity(_:) reads from it. Dumping that dictionary from a process with no Location permission showed that the parsed security elements survive the redaction:

let networks = try CWWiFiClient.shared().interface()!.scanForNetworks(withSSID: nil)
for network in networks where network.supportsSecurity(.wpa2Personal) {
    let record = (network as NSObject).value(forKey: "scanRecord") as? [String: Any] ?? [:]
    print(network.ssid ?? "<redacted>", record["RSN_IE"] ?? "no RSN")
}

<redacted> {
    "IE_KEY_RSN_AUTHSELS" = ( 2 );
    "IE_KEY_RSN_MCIPHER" = 4;
    "IE_KEY_RSN_UCIPHERS" = ( 4 );
    "IE_KEY_RSN_VERSION" = 1;
    ...
}

AUTHSELS is the list of AKM suites: 2 is a WPA2 passphrase (PSK), 8 is WPA3’s SAE, 18 is OWE. That’s enough to write the record myself and hand it to a fresh CWNetwork:

func network(_ record: [String: Any]) -> CWNetwork {
    let network = CWNetwork()
    network.setValue(record as NSDictionary, forKey: "scanRecord")  // private: probes and tests only
    return network
}

func rsn(_ akms: [Int], mfpRequired: Bool = false) -> [String: Any] {
    ["IE_KEY_RSN_VERSION": 1, "IE_KEY_RSN_MCIPHER": 4, "IE_KEY_RSN_UCIPHERS": [4],
     "IE_KEY_RSN_AUTHSELS": akms,
     "IE_KEY_RSN_CAPS": ["MFP_CAPABLE": 1, "MFP_REQUIRED": mfpRequired ? 1 : 0]]
}

let open = network(["CAPABILITIES": 0x421])            // no RSN, privacy bit off
let owe  = network(["CAPABILITIES": 0x431, "RSN_IE": rsn([18], mfpRequired: true)])
let wpa2 = network(["CAPABILITIES": 0x431, "RSN_IE": rsn([2])])

Then ask every flag. This is what macOS 27 answered:

An open network says yes to .oweTransition. So does a record with nothing in it at all. A WPA2-only network says yes to WPA3 Transition and to WPA Mixed.

It’s not a bug, it’s a different question

Once the table is in front of you, the pattern is clear. supportsSecurity(_:) doesn’t answer “does this access point advertise this mode?”. It answers “could a profile saved under this mode join this access point?”. A WPA3 Transition profile can join a WPA2 network or a WPA3 one. A WPA/WPA2 Mixed profile can join a WPA2 network. An OWE Transition profile can join a plain open network, because that’s what the open half of a transition pair is.

The base flags I checked (.none, .wpaPersonal, .wpa2Personal, .wpa3Personal, .OWE) track what the network advertises, because for them the two questions have the same answer. The transition and mixed flags are where they diverge.

It had been costing Netfox in a second place I hadn’t noticed: the security label listed every flag that said yes. A plain WPA2 network read “WPA Mixed, WPA2 Personal, WPA3 Transition”, and the list, which shows the first mode, said WPA. On my own scan that was 17 networks out of 24.

And a real OWE transition network still answers .OWE itself: an open record carrying the scan key SCAN_RESULT_OWE_MULTI_SSID = 1 (the open half of a transition pair, judging by its name) comes back yes to .OWE too. So .oweTransition wasn’t needed for anything.

The fix is small; the lesson is in the tests

// 0.29.0
enhancedOpen: [.OWE, .oweTransition].contains { cwNetwork.supportsSecurity($0) },
// 0.29.1
enhancedOpen: cwNetwork.supportsSecurity(.OWE),

The label now names only base modes, so a transition network reads “WPA2 Personal, WPA3 Personal”, which says the same thing without claiming anything the network doesn’t do.

The more interesting question is why the tests passed. The code that matches a scanned network against saved profiles was tested with a fake:

private func advertising(_ modes: [CWSecurity]) -> (CWSecurity) -> Bool {
    { modes.contains($0) }
}

#expect(profileMatches(.wpa2Personal, supports: advertising([.wpa3Transition])))

That test describes an access point that advertises WPA3 Transition and nothing else. CoreWLAN never reports one. The fake encoded my assumption about the API, so it could only ever agree with my code.

The tests now build real CWNetworks from scan records, with the same helper as above, and one test pins the premise itself:

@Test func coreWLANAnswersTheTransitionFlagsForNetworksThatDoNotCarryThem() {
    #expect(ScanRecords.open().supportsSecurity(.oweTransition))
    #expect(ScanRecords.wpa2Personal().supportsSecurity(.wpa3Transition))
    #expect(ScanRecords.wpa2Personal().supportsSecurity(.wpaPersonalMixed))
}

If Apple ever changes what the flag means, that test fails first, and its doc comment says which comment in the classifier has become stale.

Caveats, honestly

• scanRecord is private. Setting it through KVC is fine in a test target or a throwaway probe, and has no place in the app you ship.

• The keys and the table above were read on macOS 27. They’re a measurement, not a contract, which is the point of the premise test.

• None of this needs a real OWE access point or Location access, and that is what makes it worth knowing: you can check what Wi-Fi security code does with any security mode, from a test, in seconds.

The fix shipped in Netfox 0.29.1: open networks show as open again, and the security label names only the modes a network uses.

Netfox is free, a universal binary (Apple Silicon + Intel), runs on macOS 15.6+, and is signed and notarized.

• Website: netfox.app

• Download: https://netfox.app/download

Lancetta

Lancetta is new, and this is its first appearance here: a native macOS menu-bar monitor for the quotas of Codex and Claude Code — the 5-hour and the weekly window for each agent, when each one resets, and where it is heading at the pace you are going. Reading a quota costs nothing, and that was measured rather than promised: twelve reads left the account’s lifetime token counter unchanged at 318,009,023, against a day of ordinary use that moved the same counter by 29,188,602. It is free, universal, signed and notarised, and runs on macOS 15 or later. The first public release, 0.2.0, went out on 18 September and 0.13.1 on the 30th. Twenty-three releases in thirteen days is too many to list, so here is their shape.

An unknown is never a number (0.2.0 → 0.3.4). The app exists because of one status line. It showed 0% when it had no reading at all, and a three-hour-old number as though it were current — not an error, not a blank, but a confident, wrong number you plan your afternoon around. So Lancetta never draws an unknown as 0%, and every reading carries its age. Launch day went the way launch days go: 0.2.0 shipped with only the Apple silicon slice while the site said Universal, and 0.2.1 fixed it the same day. The moment a quota monitor earns its place is when an agent refuses you, and that is the moment the first builds handled worst — the whole bar collapsed into one anonymous sign that read as a minus. A refusal is now a cell of its own, with the agent’s mark, the window that refused and a countdown, while the other agents keep their turn (0.3.2). An error that used to print raw JSON as the entire Codex card — it told the developer everything and the person nothing — now arrives as one sentence with a Why, and what to do… behind it (0.3.3).

Claude stays connected (0.3.4 → 0.11.1). Claude Code rewrites its keychain item every time it renews its sign-in, and the rewrite wipes the permission you gave anyone else to read it. So macOS kept asking for your login password in the background — six times in three days, with four Always Allow grants wiped within the hour of being given. 0.3.4 stopped the dialog appearing on its own; 0.11.1 reads the sign-in the way Claude Code itself does, and normally there is no dialog at all, not even the first time. The permission was never going to last, however many times you granted it. And the pause from the opening paragraph: the account sends that refusal with no wait attached, and the card sat stuck for a minute and a half at a time. It retries after ten seconds, then twenty, then forty (0.6.2).

The number you can already see is not the useful one (0.4.0 → 0.8.0). A percentage cannot tell you whether today’s pace empties the window before it resets. A line under every bar now says it — 55% in 2 days · at this pace full by Wednesday afternoon — and turns amber only when the window would run out early. It shipped against a verdict fixed in advance: if 1,890 readings across twenty-five windows showed the quota draining as a slope, the feature would be deleted rather than softened. It came back a step — the sharpest boundary went from 100% to zero in forty-two seconds. From there: notifications only for what the bar cannot show, each said once at the moment it changes and never on launch (0.5.0); a model’s own weekly limit, which the account had been sending all along while Lancetta drew 65% and said nothing (0.6.0, 0.7.0); and a menu-bar lamp that goes green, amber and red — and grey when nothing could be read, because an unknown is not an empty quota (0.8.0).

The menu became a panel (0.9.0 → 0.11.0). You can pin it, drag it, and close it only with Escape. Durations now follow one rule: an hour and four minutes had been printing as 64m, and a day and eight minutes as 24h08m, since the app first shipped. The panel went from seven controls in three places to five in two, with Updated 14s ago across the top and a card’s own age shown only when it trails (0.10.0). And 0.11.0 shows the free reset Codex sometimes grants — the one thing in Lancetta that cannot be undone, so Use… always asks first, with two dates and Cancel as the default.

The Lancetta panel: Updated 16s ago across the top; Claude at 10% of its 5-hour window and 3% of its week, each with a line saying where it ends at the current pace, and its Fable limit at 0%; Codex spent for the week, with the free reset it holds until 22 October and a Use… button

Looking back, and everyone else’s Mac (0.12.0 → 0.13.1). A Last week card per agent says how the weekly window ran, how often the 5-hour one stopped you, and the hours nobody read — a night your Mac spent asleep is a gap, never a zero, and the card waits for one whole week before it says anything. Lancetta usage --json prints the last reading for a tmux status line or SketchyBar, and never reads an agent itself. Then 0.13.0, for machines that are not mine: an agent that is installed but not found looks exactly like one that is not installed, so a Sources pane now shows the binary, how it was found and every place searched. On macOS 27 the app had been drawing macOS 15’s controls, because Lancetta was telling macOS it had been built for macOS 15, and macOS believed it. And 0.13.1 fixed the Processes pane announcing 4 Codex trees · 1.45 GB directly above No Codex process trees are running.

https://lancetta.app

WordPress: WP Bones, Bannerize and Scotty

New to this newsletter, and not quiet about it: WP Bones, my Laravel-style framework for WordPress plugins, shipped ten releases (2.0.4 → 2.1.0), and two plugins built on it followed — Bannerize (1.13.3, 1.13.4, 2.0.0) and Scotty (2.2.0). The 14 boilerplates and their Playground demos moved with every framework release, so they get this sentence rather than fourteen paragraphs.

The command every plugin carries, read line by line (2.0.10). Every WP Bones plugin ships bones, a single PHP file you run for make:controller, version, deploy and the rest. This fortnight it was read end to end and then broken on purpose. The one that could not wait: php bones deploy <path> deleted whatever was at <path> before copying, and a five-second pause was all that stood in the way — so php bones deploy .. emptied the parent folder, every plugin beside yours and then the plugin itself. php bones deploy build went the other way, copying the plugin into its own build/, then build/build/, until the path was 160 levels deep. The deploy now checks the destination before it builds anything, and the plugin, any folder containing it and any folder inside it are always refused.

The Where the deploy goes section of the WP Bones docs: the plugin, any folder that contains it and any folder inside it are always refused, an existing folder is replaced only when it holds a previous deploy of the same plugin, and a warning that up to v2.0.9 php bones deploy .. removed every plugin beside yours

Success, reported by things that had failed (2.0.6 → 2.1.0). The rest of the audit reads like a catalogue of this issue’s thread. A broken production build printed ✅ Build completed, packaged whatever was already in public/ and exited 0. bones version announced Version updated while package.json kept the old number. The make:* generators said Created when the write had failed. An unknown command, a missing name and a prompt you answered “no” all exited 0, so a script could not tell any of them from success. And the format:check script the v2 migration writes called a formatter that ignores --check and always writes — so the “check” reformatted the plugin, compiled bundles included, and reported success. Each of them now fails like a failure. rename got the same treatment in 2.1.0: on the Internationalization boilerplate it wrote 187 files, 99 of them identical to what they had been, and corrupted the compiled .mo catalogues on the way, because a longer plugin id shifts every string while the offset table stays put.

A number that should have been zero (2.0.7). Checking what bones deploy would send to the WordPress.org plugin directory, PHPUnit was in the package — with Brain Monkey, Mockery and everything else a test suite pulls in: 31 packages nobody needs on a live site. The deploy now drops Composer’s dev packages in the copy, never in your checkout, and stops outright when it has no lockfile to do it with: a loud failure beats a quietly heavy package. The next release came from a contributor’s pull request, and gives every custom bones command its plugin — the same instance WordPress is already running (2.0.8).

Eloquent, on the database WordPress actually uses (2.0.11, 2.0.12). Open the Database boilerplate’s demo on WordPress Playground, click Eloquent ORM, and the page stopped after its first example, with the error tucked inside a collapsed Output. Eloquent always opened a MySQL connection, and Playground runs WordPress on SQLite; it now uses the same SQLite file WordPress does — Playground, WordPress Studio, any site on the SQLite plugin. Reading the other half of that function found two more: on MySQL 8.4 an emoji saved through Eloquent failed with error 3988, and an emoji saved by WordPress came back through Eloquent as a question mark, with no error at all. Charset, collation and DB_HOST parsing now come from WordPress itself.

Bannerize: a new foundation, and a security release for everyone else (1.13.4, 2.0.0). 2.0.0 moves Bannerize onto WP Bones 2 and needs PHP 8.1 and WordPress 6.6; on screen, nothing changes. Sites that cannot follow stay on 1.13.4 — and 1.13.4 is where this cycle’s security work went, so it is worth installing today: the shortcode’s order option reached the database unchecked, which let anyone who can write a post, Contributors included, run SQL of their own. It also fixes a bug you may have seen without knowing why: a banner with a maximum number of impressions or clicks refused to appear until you opened the banner list in the admin, then vanished again after the next analytics cleanup. A week earlier, 1.13.3 fixed a shortcode naming a campaign that could not be found: it rendered an empty container with no notice and no log entry, indistinguishable from a campaign that simply had no banners. Now it renders nothing, and says why in an HTML comment and a developer notice.

The Bannerize Analytics overview, unchanged in 2.0.0: impressions and clicks as two rings broken down by banner, referrer and unique IP, and below them the five most-shown and the five most-clicked banners

Scotty 2.2.0. Scotty is the maintenance plugin: cron, database clean-up, site settings. Its Run now button on the Cron page ran the job and quietly removed its recurring schedule, and the Scheduled Cron Jobs counter counted due times rather than jobs — 10 on screen where there were 12. Both are fixed; the admin also moved to Mantine 9, which needs a newer React than WordPress ships, so Scotty now carries its own.

wpbones.com · Bannerize on WordPress.org · Scotty

Netfox

Asking the devices that never speak (0.23.0, 0.23.1). Netfox found devices by listening, and a device that is switched on, quiet, and has never had a reason to talk to your Mac produced no signal at all — a printer asleep, a camera that only ever phones its own cloud. It was not hard to find; it was unreachable by construction. Now you can give Netfox a range and it asks each address one small question, and whatever answers joins the list you already have rather than a parallel one. The range stays inside your own subnet — one that reaches outside is refused rather than trimmed to fit — and it doubles as a filter, which is why the footer then shows both counts, 2 in range · 33 on the network: a filter you have forgotten looks exactly like a network that has lost thirty devices. This Mac’s Ports tab also names the process behind each open port and says whether closing it can be undone. On the machine it was measured on, only 2 of 36 running services were set to restart themselves, so a tool that said “it’ll come back” would have been wrong about the other 34.

Within hours, someone sent a screenshot from a Mac Studio on Ethernet and Wi-Fi at once: the sweep menu offered en0 and en1, both covering the same 254 addresses — two rows that did the same thing, in a vocabulary nobody uses. 0.23.1 shows one row per network, named the way macOS names the interface, in your language, and read from the system rather than guessed: on the laptop I wrote it on, en0 is Wi-Fi and en1 is Thunderbolt 1.

What a silence means (0.24.1, 0.26.0). A MySQL server had been stopped. The terminal said the port was closed. Netfox, open right beside it, still said Open. It was not wrong about what it had seen — it was wrong about when. 0.24.1 made the Ports list honest about its age: opening the tab re-checks every open port whose answer is more than a minute old, a line says how old the list is, and Full Scan now corrects what it finds instead of keeping only the ports it found open. The rule underneath is that a silence is not a close: no reply keeps the old reading, while a refusal is a real answer and is recorded at once.

Then the part I would rather tell you than not: that rule held on some paths and not on others. A scheduled scan that caught a device asleep rewrote every open port as Filtered — so an exposed Telnet port stopped counting as a risk, History logged the ports as closed, and when the device woke up, the next scan announced each of its services as newly opened. Nothing is what a firewall that drops packets sounds like; it is also exactly what a phone sounds like while it is asleep in a pocket. 0.26.0 keeps the answer through the silence, with the time it was given, and makes the menu bar, the notch, the Overview and Security share one verdict: OK means every device Netfox can reach has been scanned and none is at risk. Until now the menu bar could show a green OK before a single device had been scanned.

What are you called? (0.27.0, 0.28.0). You used to meet the same stranger three times: Apple, Inc., with a question mark for an icon — a Mac, an iPhone and an iPad, and nothing on screen to tell them apart. Plenty of devices never announce a name, and Netfox was only listening; 0.27.0 asks for the .local name, so that row now reads Annas MacBook Pro with a laptop icon, and the name is kept for up to 90 days while the device is off. 0.28.0 then lists each machine once: a Mac on a cable and on Wi-Fi at the same time used to show up twice, and two connections answering to the same name at the same moment — which only one machine can do — now fold into one row. Echo speakers are asked on the Alexa ports and named as such; makers that make many kinds of thing keep the question mark, because a wrong picture is worse than none. A test build had drawn two Belkin devices as smart plugs, and they were mesh repeaters.

The row that vanished with macOS 27 (0.22.1). Nobody wrote this bug. It arrived on the morning macOS 27 came out, in code that had been correct for years: the table that turns a Mac’s build number into a system name came up one row short, so every Mac that updated stopped showing what it runs — and a missing row is indistinguishable from a device that declined to answer. An old test had asserted that the next macOS was unknown, so on the day it shipped the test passed by agreeing with the bug. The new one asks the machine running the suite for its own build number, and goes red the first time anyone runs it on a macOS nobody has added a row for.

And how the numbers arrive (0.24.0, 0.25.0, 0.25.1). Help → Release Notes… now holds the whole history, newest first, offline and in your language — every release had notes in six languages inside the app, and you simply could not reach them. On macOS 26 and later the menu-bar panel and the Overview cards are glass, tinted in the colour of the tool each one opens, with the colour under the glass so it survives an inactive window, which is where a network monitor spends most of its life. Numbers roll in after a deliberate beat, cards land on a spring, a refresh presses each card instead of re-running the show, and on macOS 27 you can pull a view down to refresh it, as in Mail. With Reduce Motion on, nothing moves. And 0.27.0 swaps the old notes panel for the same small update card FinderGit got a day later.

The Netfox menu-bar panel in glass: 12 of 36 devices online, a risk ring at 4 with 0 high and 4 medium, the public IP with no VPN, 3 alerts in the inbox and a traffic line, with the violet Open Netfox button at the foot

https://netfox.app

FinderGit

The tabs say what is waiting inside them (0.36.0, 0.37.0). Finding out what was open on a repository meant clicking Issues and counting, then Pull Requests and counting again. Repeat that across a folder of thirty repositories and you have spent a real minute on a question with a one-digit answer. The two tabs now carry their open count, and a tab with nothing open carries no number at all — Bitbucket’s Issues tab stays bare rather than claiming a zero nobody ever told it. The count costs nothing, because it is the one the file browser’s columns already had, and arrowing past a repository fetches nothing. Underneath was the bug this issue is about: a repository whose remote could not be read once — a lock file left behind by another git action is enough — was quietly written off for the rest of the session, counts and all, with no way to bring it back. Refresh now asks again. The next release gave every issue and pull request a second line saying who opened it and how long ago, because a title on its own does not tell you whether you are looking at something from this morning or something that has been sitting there since spring. It costs not a single extra request: the data arrived with the list, and was being thrown away.

The FinderGit detail panel on a repository with open work: the Issues tab carries an orange badge reading 17 and Pull Requests a purple 1, the other seven tabs carry none, and every issue row says who opened it and how long ago

Branches, without the terminal (0.38.0). Create, rename, merge, rebase and delete, beside the listing and switching that have been there since 0.11.0. A remote branch offers only Merge — a push to a remote that usually belongs to somebody else has a different blast radius. The rebase confirmation says git will check out the branch being rebased before you agree, not after, and a delete git refuses offers the forced option in the same dialog rather than a dead end. Kaleidoscope gets a button beside Refresh Diff, drawn only if you have Kaleidoscope: a permanently greyed control advertising an app you have not bought tells you nothing you can act on. And twenty-eight count strings in Italian, French, German and Spanish had been reading as plurals at one.

Your own AI key, a whole changeset, and the file that made your repo heavy (0.39.0). Commit messages can now come from your own provider and key, kept in the macOS Keychain; the diff travels from your Mac straight to the service you picked, and a key that cannot be verified is saved unconfirmed, rather than claiming more than the app knows. Diff All sends staged and unstaged changes to Kaleidoscope as one changeset, and lists underneath whatever could not be sent, and why. And the one I have wanted for years: the twenty largest objects in a repository’s history, files deleted long ago included — with the rewrite offered as a runbook rather than a button. FinderGit never runs those commands itself.

Dashboards that arrive (0.40.0). The Overview and Account cards land one after another and their figures roll up; they are glass on macOS 26 and later, and on macOS 27 you can pull them down to refresh, as in Mail. With Reduce Motion on, nothing moves. After an update, a small card names the version, and Learn More… opens the Release Notes window, where a release’s unread dot now goes the moment you open it.

https://findergit.app

octoscope

Your activity, in the order it happened (0.35.0). octoscope has a quiet half — --json and --plain, the part you pipe into a status bar or a cron job — and until now it could tell you everything about your repositories and nothing about you. --activity changes that. One decision worth knowing if you build on it: when you do not ask for the feed, the recent_activity key is absent, not empty. An empty list would be a claim — we looked, there was nothing — and that claim would be false. A missing key lets a script tell did not fetch from nothing happened.

Wiring it in turned up the part nobody went looking for: the feed had never been in chronological order. 27 of 99 adjacent events came back out of sequence, then 28 in the next feed, then 25. The events endpoint is not documented as sorted, and it is not; octoscope had been trusting the order it was handed, so the Activity tab has been showing an almost sorted list for months — worse than an obviously unsorted one, because it reads as correct. It is sorted where events are parsed now, so the tab and the reports are fixed by the same change. The supply-chain scan also started reading the repository’s own settings: a workflow reacting to discussions, on a repository with discussions turned off, is not an exposure. That moves scores in both directions — fewer findings where settings make a trigger unreachable, more on private and internal repositories, where the axis used to stay quiet.

Someone to wait with (0.36.0). Every screen before the dashboard now opens with a small octopus and its periscope, drawn with the terminal’s own quadrant block characters and wearing your theme’s colours; once the dashboard is up, a smaller one stays beside the banner and looks around whenever a refresh runs. It moves on the spinner’s own ticks and stops when the spinner does, so it never adds a moment to the wait it keeps you company through. One honest caveat: a terminal font without those block characters shows boxes where the octopus should be.

octoscope 0.36.0 on the Overview tab: the small octopus beside the banner, then the profile card, the social and activity counters, the languages bar and the top repositories, with the last refresh and the automatic interval in the footer

The less visible half of the release is about time. Pressing r used to leave the automatic refresh on its old schedule, so it could fire seconds after yours, asking GitHub for what you had just fetched — or, after a rate limit, spend one more request against a limit you had already hit. Now every answer from GitHub decides when the next automatic refresh runs, whoever asked for it. Measured against the real API with a 30-second interval: before, the automatic refresh went out 7 seconds after a manual one; now it goes out 30 seconds after. And the scan stopped mixing branches: a trigger found in one branch’s copy of a workflow was being scored together with a secret found in another branch’s copy of the same file, so two harmless files could add up to a score of 3 for a capability that existed on neither.

https://gfazioli.github.io/octoscope · brew upgrade gfazioli/tap/octoscope

Mantine extensions

A quiet fortnight by design: on the 29th all 26 components moved to Mantine 9.6.3 in one sweep — one patch each, nothing you have to do — and the two documentation templates moved with them. The one fix with a story is on the extensions site. In Firefox, hovering a card under All Extensions flooded the whole thumbnail with the BorderAnimate ring’s gradient instead of drawing the thin travelling ring; it was reported on Discord against Firefox 156, and the card now stacks one transform instead of three.

mantine-extensions.vercel.app

The Raycast extensions

One contribution this time, to Open Folders: a new Open Folders In preference decides where Finder shows a folder you open from the extension — a new window, as before, a new tab in the front Finder window, or the current tab. The new-tab mode has a catch worth stating up front: Finder’s scripting dictionary has no command for tabs, so the only way in is ⌘T through System Events, which needs Accessibility permission for Raycast — and the preference says so rather than failing quietly. When Finder cannot be scripted, the folder opens in a new window with a HUD explaining why.

Open Folders · raycast.com/Undolog

And on the site

gfazioli.github.io has a Lancetta card in the macOS section, the Italian page now tells search engines it is Italian, and switching language no longer makes the page jump 80 pixels. The React component libraries shipped nothing this fortnight; the last release of each still stands.

Undolog — open source studio. Every project in one place: gfazioli.github.io · this newsletter lives at undolog.com

• FinderGit — a Git-aware file browser for macOS · findergit.app

• Lancetta — a menu-bar monitor for the quotas of Codex and Claude Code · lancetta.app

• Netfox — a network monitor for macOS · netfox.app

• octoscope — a terminal dashboard for GitHub · gfazioli.github.io/octoscope

• WP Bones — a Laravel-style framework for WordPress plugins, with Bannerize and Scotty built on it · wpbones.com

• Mantine extensions — 26 components on npm · mantine-extensions.vercel.app

• Raycast extensions — for the Raycast launcher · raycast.com/Undolog

FinderGit

Open a commit like a folder (0.29.0). Reading a commit list, you want to know one small thing: which files did that one touch? Every commit now has a chevron, and opening it is exactly like opening a folder — the files, git’s status letter, the old name where something was renamed, and a read-only diff scoped to what that commit did to that file. Deleted files open too, because what a commit removed is often the part worth reading. Issues and pull requests open in place as well, with the whole conversation: the body a reviewer submitted with their verdict, and the notes pinned to individual lines. A pull request reviewed entirely inline — which is how most of them are — used to look as though nobody had said a word.

The same release fixed something I would rather tell you about than not. Discarding a file whose name contains *, ? or square brackets could revert a different file, because git reads those characters as a pattern: asking it to restore a[1].txt restored a1.txt instead, and discard has no undo. If you have never named a file that way, this never touched you. If you have, it did so without saying anything, which is the part that bothers me.

An empty cell is not a zero (0.30.0). GitLab and Bitbucket now fill in their own issue, pull-request and star counts with no account and no token, joining GitHub and Codeberg. Adding two forges was the easy half. The half that took the time was being honest about what each one cannot answer: Bitbucket retired its issue tracker, so its Issues cell is now empty while a GitHub row above it reads 0, and those are different facts that finally look different. The rule now runs through everything — a count that could not be obtained shows nothing rather than zero, whatever the reason.

The one that mattered most was forks. Only GitHub will say how far a fork trails its upstream; the other three answer with a 0 that means no permission to tell you, and FinderGit had been handing that zero straight through to a banner drawn as a green “Up to date with upstream”. A fork three hundred commits behind looked current.

Your tags and your releases, side by side (0.31.0 → 0.33.0). There is a quiet lie every Git tool tells: ask for your tags and you get the ones in your clone. A tag you cut this morning and never pushed looks exactly like one the whole team has had for a year. A new tab pairs every tag with the release cut from it and marks each row on both, local only or not fetched — and the buttons follow from that, so Push is drawn where there is something to push and nowhere else.

Two people then found the rest of the release. One opened it on a repository with 715 tags, selected three from four years ago, and found the bar carrying every action several hundred rows above, off the top of the panel — it is pinned now. The other asked why v1.0.2 sat at the bottom of a 207-tag list, under one six days older. The answer is that git has two kinds of tag: an annotated tag is a real object with its own date, while a lightweight tag is a name pointing at a commit, and git records nothing about when it was made — so the only date available is the commit’s. The sort was correct, and there was no order in which it read correctly. Rows now say which kind they are, and a commit subject is drawn behind its own mark rather than where a tag message would go: the two were written by different people at different times, and a commit subject printed as a tag message is a caption that lies.

Deleting a tag everywhere is one action now, and it runs the remote first, deliberately: if the remote refuses, your local tag is untouched and retrying costs nothing — the other order destroys the last reference naming that commit and only then discovers it could not reach origin.

You should not have to be watching (0.34.0). You start twenty tag deletions, look away, and never find out how it went. Every action now reports itself in a card in the corner carrying git’s own words — not a paraphrase, not “an error occurred” — and the card leaves on its own, because a stack you have to dismiss gets dismissed reflexively without being read. What stays is the bell: a failure lights the badge and keeps it lit, a success does not, so the badge means “something needs you” rather than “something happened”. Bulk runs show their progress, and a run you stop marks the tags it never reached as not attempted rather than guessing — the one you may have to check by hand is precisely the one a guess would hide.

A fetch that failed reporting itself in the corner with git’s own message, while the bell in the toolbar carries the unread badge

A position is not a name (0.35.0). Stash moved down to the bar beside Fetch, Pull and Push, where you actually reach for it — the old placement vanished at exactly the moment you wanted it, because pressing Stage All emptied the list whose header it lived in. But the fix worth reading about is underneath: every row in the stash list carried its position, and a position renumbers when something above it is dropped. A list read a moment earlier could point Pop at a different stash than the one under your cursor, and because the changes it applied looked perfectly plausible, nothing on screen would ever have told you. A stash is identified by its own commit now, resolved at the instant the action runs.

It took six rounds of review to land, five of them patching one window at a time while a sixth kept opening. What finally worked was changing the question: not “where is a check missing” but “which decision here is being made on data nobody validated”.

And the two that belong to this issue’s thread. A translation coverage report had been reading 100% while 189 user-facing strings had never entered the catalogue at all — it was right on its own terms, because a string that never became a key cannot be reported as missing. And a rule about how SwiftUI reports sizes, credited with fixing a clipped panel and then cited by every popover fix since, turned out not to be true: a measurement puts each shape into the real sizing path and reports the same height with the modifier and without it. The measurement is now in the repository, so next time the answer comes from running something rather than remembering a sentence.

https://findergit.app

Netfox

Is it my connection, or the internet? (0.18.0) A new Link panel reads the layer under the IP address: what the cable or the radio actually negotiated, the error counters, and how much of the delay is your own link against everything past your door. Every latency figure is a minimum rather than an average, and that was measured rather than assumed — across five bursts the minimum moved under 1 ms while the average moved over 100 ms, so an average would have blamed your link for the internet’s bad day.

The part I would point at, though, is what the panel refuses to say. A link nothing has crossed gets no clean bill of health: it has not been shown to be fine, it has been shown nothing. A radio that is switched off has no band and no channel, so those are left out rather than filled in with “Unknown” — an absence rendered as two facts is worse than a gap. And a router that ignores pings is reported as untimeable rather than broken, because plenty of them drop pings by policy.

The Netfox Overview with the new Link panel: the wired half, the radio and its headroom, the error counters, and the first-hop split

What a certificate says about itself (0.19.0, 0.19.1). Every home network has a few: the NAS admin page, the printer, the router, a Home Assistant box. They all speak TLS, and almost nobody ever looks — until a browser refuses to open one and you are guessing whether the device is broken, misconfigured, or just doing what home devices do. Netfox now reads the certificate and says plainly whether it is expired, expiring within three weeks, self-signed, or not yet valid, which on a home network almost always means the device’s clock is wrong rather than the certificate. The next release added how the two of you are actually talking — the negotiated version and cipher, flagging an obsolete version or a key exchange with no forward secrecy, and honest that this is one server’s answer to one negotiation with your Mac, not everything it could do.

The server you forgot you started (0.20.0). A test run finishes, the terminal window closes, and something it started keeps holding port 3000. Netfox scans your network, and a server bound only to loopback is not on your network — so 0.20.0 looks in the other direction. The finding is not that a port is open: it is that the process was left behind. It waits fifteen minutes from the moment of orphaning, and it only reports listeners every process of which is yours, because one you cannot act on is not a finding, it is a nag. The naive version of that rule fired on three services out of eight on a test machine, all of them Apple’s own.

The one port worth asking twice about (0.21.0). There is one port on a home network more likely than any other to be running something it should not, and it is the boring one: 445, file sharing. What matters is not that it is open but which version the other end speaks — and a device that speaks only SMB 1 does not reply to a modern request at all. It just says nothing. Ask once and take silence for an answer, and the device most worth warning you about is the one reported as fine. So it asks twice, and where it cannot settle the second question it says nothing rather than telling you SMB 1 is off: a reassuring sentence about a question nobody managed to ask is worse than no sentence.

The same release found the landing screen burning 9.6% of a processor against 0.6% on any other screen — beside a comment in the code claiming “well under 1%”.

A window that fits where you put it (0.22.0). If you have ever dragged Netfox to one side of the screen to watch it while you worked, you know it refused to go narrower than 960 points and its right edge simply left the display. It now goes down to 500×340 and changes shape rather than squeezing: not a smaller version of the page, a different one, with the figures that matter all on screen at once. Fixing it also turned up a click at that size that selected nothing — while 959 existing tests passed the entire time. There is now one that clicks a row at that size and fails if nothing opens.

And the one I would rather have not shipped: every build up to 0.18.0 carried a setting that belongs on a development machine, the one that lets a debugger attach to a running program and read whatever it is holding. Nobody added it — it arrives automatically on a development build, and the step that prepares the release faithfully preserved everything the build had produced. That is fixed in 0.18.1.

Netfox in its widget shape: four tiles filling a small window — risk posture at 3 medium and 29 low, 23 devices of 32 on the network, the public IP on a direct connection, and 3 alerts — with every figure on screen at once

https://netfox.app

octoscope

The version it prints is the version you have (0.31.1). Every octoscope release is built with a linker flag whose entire job is to stamp the tag into the binary. It never did anything: the version was declared as a Go constant, and the linker cannot patch a constant. No warning was ever emitted, so nobody knew — and here is the honest half, measured rather than assumed: across all 42 releases the hand-edited line had matched its tag every single time. What was missing was never correctness. It is that nothing checked. There is a test now, and it was written carefully, because a check that can silently measure nothing is precisely the failure this release is about and it would be a poor joke for it to be one itself.

Your lockfile, read line by line (0.33.0). The lockfile is the one part of a pull request nobody reads that way. The scan now does it for you, flagging dependencies that newly run install scripts and versions republished with different bytes. Worth knowing how rare that is: across the last twenty revisions of the lockfiles in axios, npm/cli and undici — fifty-seven revisions in all — the files churned the entire time, the subset that runs code at install moved twice, and the same version was republished zero times. It is npm only, and the report says so on every repository it could not compare, because silence would look exactly like nothing here runs code at install, and that is the one thing it must never imply.

It stops blaming you for your own refactor (0.34.0). You reorganise a monorepo and the scan lights up. Nothing started; you moved a folder. Packages are now keyed by their declared name rather than their path, and the fix was measured before it was chosen: across 115 workspace entries in seven npm-workspace monorepos, 85 carried a name, and all 85 differed from the directory they sat in. A baseline recorded in the old format now reads as not comparable instead of being diffed against a different naming scheme.

And a green release that did not mean what it looked like (0.34.1 → 0.34.3). If you installed 0.34.0 on macOS and the command did nothing at all, that was real and it was ours: a Homebrew cask’s download is quarantined, unlike a formula’s, and Gatekeeper killed the ad-hoc-signed binary at launch. The stopgap stripped the quarantine flag, the next release found that the hook it used had been deprecated in a way that actually broke installs, and 0.34.3 closed it properly — Developer ID signing and Apple notarization, which also covers what Homebrew never could: a .tar.gz downloaded straight from the releases page.

The measured finding along the way is the one I would keep: signing without notarizing changes nothing at all. The binary is still killed, and spctl still reports it rejected. There is now a CI job that downloads the published binary, checks its notarization, re-quarantines it and actually runs it — with a negative control, an ad-hoc-resigned binary that must fail, so the check cannot pass silently on a runner that is not enforcing. brew install exiting 0 is exactly what the broken release did.

Also in the fortnight: octoscope now installs four ways rather than two — as a gh extension, a roughly 7 MB container image, a standalone platform binary, or through Homebrew — and CI builds and runs the Windows binary natively for the first time, having shipped one since v0.2.0 on the strength of cross-compilation alone.

octoscope 0.34.3 on the Overview tab: the profile card, the social and activity counters, the languages bar, the top repositories by stars and the network row

https://gfazioli.github.io/octoscope

Mantine extensions

A window gesture you can compose (mantine-window 3.2.0). Window now emits onDragStart, onDragEnd, onResizeStart and onResizeEnd, completing a set that previously had only the two change callbacks — and those fire on every frame. The edges are what make a gesture composable: persist a layout once when it ends instead of debouncing by hand, pause an expensive child while the user drags, record one undo entry per gesture rather than one per pixel.

Two guarantees came out of the implementation rather than the API sketch. Every start is paired with exactly one end — the global listener ends both gestures at once, so a naive implementation would have emitted an unpaired onDragEnd during a plain resize — and no start is emitted without a real gesture, so a press on a resize handle, an interactive child or a data-no-window-drag region never opens one that would not close. Verified with real pointer events in a browser rather than only in jsdom: across one drag and one resize the continuous callbacks fired 20 times and the lifecycle ones twice.

Beyond that it was a fortnight of alignment: the whole family moved to Mantine 9.6.0 at the start of the period and to 9.6.1 at the end of it, which is two publishes for every component and nothing you have to do.

mantine-window · mantine-extensions.vercel.app

The Raycast extensions

macOS Tweaks went from 108 tweaks to 129, with a new Windows & Stage Manager category covering Stage Manager, the Sonoma click-the-wallpaper behaviour and Sequoia’s window tiling, plus a modifier key for each hot corner — the corners were already there, the modifiers that stop them firing by accident were not. Four AI tools make a 129-entry catalogue findable, because nobody looking for “let me see hidden files” knows to search for com.apple.finder AppleShowAllFiles; the two that write both ask for confirmation showing the exact defaults command and which process will restart.

Every domain and key was verified against a live system, and each declared default was diffed against the real current value — which caught one that had been wrong: double-clicking a title bar has defaulted to Fill since macOS 15, not the older Maximize. In the same spirit, the two smart-quote tweaks had been showing as modified when untouched, because defaults read prints non-ASCII characters as escape sequences and the comparison never matched.

App Updates got its Sparkle scan under control: reading the Info.plist of every app in /Applications used to fan out one process per installed app. Measured on a 32-app machine, that was 31 concurrent processes before and 8 after, with an identical scan result.

https://www.raycast.com/Undolog

And on the site

gfazioli.github.io now opens with the three most recent releases across every project and a count of the last thirty days, so the front page answers “what has been happening” before you go looking. The macOS app cards are backed by their public website repositories, which is why they finally carry real descriptions and dates.

The React component libraries — flip, tilt, toggle and the guru meditation — shipped nothing this fortnight; they are stable and the last release of each still stands.

Undolog — open source studio. Every project in one place: gfazioli.github.io · this newsletter lives at undolog.com

• FinderGit — a Git-aware file browser for macOS · findergit.app

• Netfox — a network monitor for macOS · netfox.app

• octoscope — a terminal dashboard for GitHub · gfazioli.github.io/octoscope

• Mantine extensions — 26 components on npm · mantine-extensions.vercel.app

• Raycast extensions — for the Raycast launcher · raycast.com/Undolog

FinderGit

Put the working tree down for a minute (0.28.0). There is a kind of interruption where a commit is the wrong answer — you are not finished, and a commit you would have to undo is worse than none. The Unstage tab now carries a Stash… button beside Stage All and Discard All. Give the stash a message or let git name it after your last commit; untracked files come along, so what you get back is a genuinely clean tree rather than a half-tidied one.

Everything you have set aside is listed under the commit box with the branch it came from and how long it has been waiting — because the stash that matters is the one you forgot about, and “last month, on a branch you have since deleted” is the sentence that tells you what to do with it. Pop, Apply, Drop. A pop that hits a conflict leaves the conflict in your files and the stash still on the list.

And a failed action no longer goes quiet (0.28.0). When a git action failed, the red warning in the action bar could vanish a second or two later — on exactly the actions that had changed something on disk, because re-reading the repository overwrote the message with “nothing wrong here”. The failure now outlives every refresh, which is what “Last action failed” always claimed to mean.

Codeberg, with nothing to set up (0.27.0) — and then the part that did not work (0.27.1). Codeberg answers questions about public repositories without asking who is asking, so FinderGit can simply ask: issues, pull requests, stars, description, topics, latest release, no account and no token. Except in the file browser, where those columns stayed empty and the fork badge never appeared — two checks asked “is this GitHub?” before the new per-host routing ever got a say. Fixed the next day. If you installed 0.27.0 and wondered why the columns were blank on Codeberg: that was this, not your setup.

The same release stopped repositories on GitLab and Bitbucket from borrowing another repository’s numbers. A project mirrored under the same owner and name on two hosts could show counts, issues and pull requests belonging to the other one; those columns now stay empty rather than confidently wrong.

A slow git operation can be stopped (0.26.0). Three seconds in, Fetch, Pull and Push turn into a stop control — and the app tells you what stopping left behind, which is the part that actually matters. A stopped fetch is harmless. A stopped push leaves the remote updated or untouched, never half-way. A stopped pull is the one to know about: if it had started merging you may be left mid-merge, and FinderGit notices and offers Finish and Abort. The three-second delay is deliberate — without it, a double-click on Fetch would cancel the fetch you just started.

Every release page now also publishes the SHA-256 of its DMG, back to 0.4.1. If a virus scanner ever flags a download, “is this really the file that was published?” is a question that should not depend on asking me.

https://findergit.app

Netfox

Is my Wi-Fi the problem? (0.17.0) The Wi-Fi tab always showed you the numbers. It never told you what they meant. Open the network you are connected to and it now answers in a sentence: the link looks fine, the channel is busy, the signal is weak, or both at once — which matters, because a busy channel and a weak signal call for opposite moves and the numbers alone never said which you had.

Behind the verdict: how many networks share your stretch of spectrum, how many of them are close enough in strength to genuinely compete for the channel, and your signal-to-noise ratio. It names a quieter channel when one exists, judged by the width your access point would carry there, and counts an 80 MHz neighbour on channel 36 as the four channels it really occupies.

The competing-neighbour threshold is measured rather than chosen: in a real dense environment — 33 access points visible at 5 GHz, median −85 dBm against a −58 dBm link — the count sat flat at 2 all the way out to 15 dB and only then climbed. And where macOS gives no noise reading, the signal half is reported as unknown rather than assumed to be good. Nothing new is probed for any of it; it all comes from the scan the tab already performed.

A hidden network is now explained rather than merely labelled, too. Withholding the name is widely believed to be a security measure and is not one — the devices that already know the network broadcast its name while they look for it.

Free a port, without a terminal (0.17.0). Netfox would show you that something was holding port 3000; the next step was still kill. Each Local Services row now asks that process to quit — politely first, so a dev server can save what it was holding, then offering to force the matter. It asks the whole process family, not just the one that opened the socket, and it re-reads the port immediately before sending anything: PIDs get reused, and a row is a snapshot of a moment that has already passed.

One device, one icon (0.17.1). The same device could carry a different icon in the device list, in its own alerts, in its History window and in the tag editor — and could change between launches with no setting touched. Three separate causes, all closed: a stored category decided by whichever concurrent discovery answered first (a HomePod advertises both an audio and a display service, so “first” was genuinely random), three surfaces reading the raw stored value instead of the one the list shows, and alerts whose snapshots had dropped the model and the advertised services. Some devices also answer “what are you?” with an internal board code; where Netfox recognises the code, the Model row now reads Apple TV instead of a string of letters and digits.

A hosts name belongs to the address, not to each service (0.16.6). One name pointing at 127.0.0.1 reaches everything listening there, so it was printed beside every service — true of all of them, useful for telling apart none. Those names are now stated once, in the group heading.

https://netfox.app

octoscope

Four things that used to send you to a browser (0.29.0). Gists, with the file contents syntax-highlighted and c copying the code rather than the link. An activity feed beside the contribution heatmap — pushes, pull requests, reviews, issues, releases, branches — because the heatmap answers how much and the feed answers what. Sponsors received and given. And your real GitHub inbox: mentions, review requests, assignments, CI. s cuts the noise, and that key exists because of a measurement rather than a preference: of 104 notifications on a real account, 77 were CI activity.

When it’s GitHub, octoscope says so (0.30.0). octoscope does nothing but talk to GitHub, so when GitHub degrades every symptom — a timeout, an empty tab, a 502, a scan that will not finish — is indistinguishable from octoscope being broken. It now asks GitHub’s own status page and tells you which it is, at the moment you are deciding who to blame. It stays silent while GitHub is healthy, and silent again if the status page itself cannot be reached: it never renders a green “all systems operational”, because that would be a clean bill of health it has not verified.

Three more of exactly that shape shipped in the same release, and all three came from a comment under the 0.27.0 launch — someone who did not ask for features, but found three places where the report said more than it had checked. The scan now states the window it compared against (“compared against a baseline recorded 29 days ago”), including where nothing changed, which is the case that matters most and the one a per-finding note could never reach. A uses: into a repository octoscope did not read is now always disclosed, not only where an outsider could reach the caller. And a file that changes back — A → B → A — is recognised as a return instead of printing a hash nothing remembered.

And the tab that pushed everything off screen (0.30.1). On 0.30.0, opening What’s new carried the banner, the profile card and the tab bar off the top of the terminal, with no way to scroll them back. Reported with a screenshot, which is the only way this kind of defect gets found. Two faults, different in kind: the entry was the longest ever shipped, and the tab had never been able to scroll at all — the only long static surface in octoscope without a viewport. The shorter text alone would not have fixed it, so there is now a test that measures every What’s new entry against a line budget.

https://gfazioli.github.io/octoscope · brew upgrade gfazioli/tap/octoscope

Mantine extensions

mantine-json-tree 3.4.0 — the JSON viewer you can type into. Opt-in editable: click a string or a number for an inline editor, click a boolean and it toggles outright since there is nothing to type. The component stays controlled — it holds no copy of your data — and onChange hands you the new data plus a description of what changed. Writes preserve identity: only the spine down to the target is rebuilt, so a Date, Map, Set, RegExp, BigInt or React element elsewhere in the tree survives an edit unchanged, where a structuredClone would have flattened every one of them. Nodes with no real address — the children of a Map or a Set — can never be edited, whatever you configure. Renaming keys and adding, removing or reordering nodes are deliberately out: they need a different path format, which is a larger piece of work rather than more of this one.

mantine-json-tree 3.3.0 — three ways the tree could hide your data. A circular reference crashed the component and took the whole page with it; repeats now render as [Circular]. Plain data shaped like { type, props } — an everyday shape in form-builder and low-code JSON — was mistaken for a React element and collapsed into <Component />, hiding its entire subtree; elements are now identified by their $$typeof marker alone. And Ctrl/Cmd+C copied the root instead of the focused node, including while you were trying to copy text out of the search field.

mantine-border-animate 3.0.0 — a border that can measure something. variant="draw" with progress draws that share of the real perimeter, corners included, so 50% is exactly half the way around whatever the aspect ratio is. A dash variant whose pattern is expressed in perimeter percentages rather than pixels, so it stays even at any size. A comet beam with a fading tail at constant speed on any shape. And trigger — hover, focus-within, inView — so a border can wait for an interaction instead of looping forever; focus-within is the answer for form fields, with no state to wire up.

All three stroke-based additions come from one primitive, a <rect> with pathLength="100", checked across Chrome, Firefox and Safari before the API was designed around it — so there is no ResizeObserver and no JavaScript per frame. It is a major for a reason: four props were renamed (angle → progress, divide the old value by 3.6; delay → phase; size → spread; two beamMode values), each with a one-time development warning and an upgrade guide.

Both have a live demo with every variant on it, which is a better argument than any paragraph here: mantine-json-tree · mantine-border-animate

The Raycast extensions

The whole family moved to Raycast API 2.x, and the menu-bar icons that broke on Raycast 2 work again. Two got rather more than a migration: macOS Tweaks gained a Windows & Stage Manager category and 21 new tweaks, and App Updates gained release notes and a shared scan that makes the lists instant. Both are now usable from Raycast AI as tools, not only as commands.

https://www.raycast.com/Undolog

Undolog — open source studio. Every project in one place: gfazioli.github.io · this newsletter lives at undolog.com

• FinderGit — a Git-aware file browser for macOS · findergit.app

• Netfox — a network monitor for macOS · netfox.app

• octoscope — a terminal dashboard for GitHub · gfazioli.github.io/octoscope

• Mantine extensions — 26 components on npm · mantine-extensions.vercel.app

• Raycast extensions — for the Raycast launcher · raycast.com/Undolog

Introduction

Two bug reports landed within days of each other. One said the tour popover ignored the position prop and clipped off the left edge of the screen. The other said long content blew the popover past the viewport, with no obvious way to rein it in. They looked like two different problems — until they turned out to be the same missing constraint. Version 4.0.8 adds it, and both reports closed with a single fix.

What’s New

A sensible default width for the tour popover

The popover dropdown now has a default max-width of 400px. Previously it grew with width: max-content and no ceiling, so wide or non-wrapping content — an image, a <Code> block, a fixed-width layout — could push it well past the edge of the screen.

The cap is applied as a CSS class on the dropdown rather than inline styles, which matters more than it sounds: it survives any popoverProps.styles.dropdown override of other properties (padding, background, and so on). You only change the width when you explicitly ask to:

<OnboardingTour
  focusRevealProps={{
    popoverProps: {
      // Narrower than the 400px cap:
      width: 320,
      // Or lift the cap for a wider popover (width alone can't exceed max-width):
      styles: { dropdown: { maxWidth: 560 } },
    },
  }}
  tour={steps}
>
  {/* ... */}
</OnboardingTour>

The “broken position” was really a width problem

The second report — a popover that ignored position and stuck to the left edge — had the same root cause. While a tour is active, the component sets overflow-x: hidden on the document to keep portal-rendered popovers from creating horizontal scroll. An unconstrained, too-wide dropdown positioned to the left of a left-edge target had nowhere to go, and the hidden overflow clipped it. Floating UI’s shift middleware can move a popover, but it can’t shrink one. Cap the width, and positioning behaves again — with no position changes required.

Consistent positioning across Mantine versions

Mantine 9.3 flipped the Popover default for preventPositionChangeWhenVisible to true, which pins a popover to the side it opened on and stops it from flipping or shifting while it stays visible. The tour scrolls targets around between steps and relies on continuous re-positioning, so 4.0.8 sets preventPositionChangeWhenVisible: false in its default popoverProps. The behavior is now identical whether you’re on Mantine 9.2 or 9.3+, and you can still opt into the pinned behavior per tour or per step:

<OnboardingTour
  focusRevealProps={{ popoverProps: { preventPositionChangeWhenVisible: true } }}
  tour={steps}
>
  {/* ... */}
</OnboardingTour>

Improvements

Step-level popover config no longer overrides tour-level settings

Tour-level and step-level focusRevealProps are now deep-merged for popoverProps and overlayProps. Before, a step that set its own popoverProps replaced the tour-level object wholesale — so a tour-wide position or style silently vanished for that step. Now a step only overrides the keys it actually sets:

<OnboardingTour
  focusRevealProps={{ popoverProps: { position: 'bottom', shadow: 'xl' } }}
  tour={[
    {
      id: 'step-2',
      title: 'Just this step',
      // Only `position` changes here — the tour-level `shadow: 'xl'` is kept.
      focusRevealProps: { popoverProps: { position: 'right' } },
    },
  ]}
>
  {/* ... */}
</OnboardingTour>

Getting Started

This is a drop-in patch — no API changes, nothing to migrate.

yarn add @gfazioli/mantine-onboarding-tour@4

Compatible with Mantine 9.x and React 18/19 (the peer range stays >=9.0.0). If you were hard-capping the popover width yourself as a workaround, you can drop it — or keep it: an explicit styles.dropdown.maxWidth or width still wins over the new default.

New docs: the Popover width section (with a runnable demo) and the preventPositionChangeWhenVisible note in Scroll Behavior.

Links

• 📦 npm: https://www.npmjs.com/package/@gfazioli/mantine-onboarding-tour

• 📖 Docs: https://gfazioli.github.io/mantine-onboarding-tour

• 💻 GitHub: https://github.com/gfazioli/mantine-onboarding-tour

• 🧩 Mantine Extensions Hub: https://mantine-extensions.vercel.app/

I build Netfox, a macOS network monitor. It lives in two places at once: a full window, and a menu bar popover that shows your network at a glance — devices online, risk level, public IP, a little live traffic chart.

The popover has four status cards. Someone asked the obvious question: “can I click a card and have it open that section in the main window?”

Sure. Easy. Except it wasn’t, and the reason why is a nice little lesson about how SwiftUI scenes are isolated from each other.

Why the obvious approach doesn’t work

In a single-scene SwiftUI app, the way you’d wire a “menu command triggers an action in a view” is @FocusedValue / .focusedSceneValue. The view publishes a closure; a command elsewhere reads it. Clean.

But a MenuBarExtra is its own scene, separate from your WindowGroup/Window. Focused-scene-values are scoped to a scene tree — they don’t cross from the popover scene into the main window scene. So the popover literally cannot reach the main window’s selection state that way.

And it gets worse. My app is “dual-mode”: closing the main window doesn’t quit it (the MenuBarExtra scene keeps it alive). So at the moment a popover card is clicked, the main window might not exist at all. There’s no view to send a message to.

You can’t message a window that isn’t there.

The shape of the fix: a tiny shared router

The trick is to stop thinking “popover → window” and start thinking “popover → shared state → window, whenever it shows up.”

A ten-line @Observable singleton both scenes can see:

import Observation
​
@MainActor
@Observable
final class ShellRouter {
    static let shared = ShellRouter()
​
    /// Section the shell should switch to at the next opportunity.
    /// `nil` = nothing pending.
    var pendingSection: AppSection?
​
    private init() {}
}

That’s the whole bridge. The popover writes to it; the window reads from it.

The popover side: queue, open, dismiss

private func openSection(_ section: AppSection) {
    ShellRouter.shared.pendingSection = section   // queue the destination
    openMainWindow()                              // raise / recreate the window
    dismiss()                                     // close the popover
}

openMainWindow() is just openWindow(id: "main") plus NSApp.activate(...). If the window was closed, openWindow recreates it. If it was already open, it comes forward. Either way, a fresh pendingSection is sitting in the router waiting to be consumed.

The window side: the part everyone gets wrong

Here’s the subtlety. You need to consume pendingSection in two places, because there are two completely different timelines:

NavigationSplitView { ... } detail: { ... }
    // Timeline A: the window was CLOSED and just got recreated.
    // Its .task runs on mount — and a value set *before* mount
    // can’t be observed by .onChange, because .onChange only fires
    // on *changes that happen while mounted*.
    .task { consumePendingSection() }
​
    // Timeline B: the window was ALREADY OPEN. The popover sets
    // pendingSection while the shell is mounted — .onChange catches it.
    .onChange(of: router.pendingSection) { _, _ in
        consumePendingSection()
    }

private func consumePendingSection() {
    guard let section = router.pendingSection else { return }
    selectedSection = section
    router.pendingSection = nil          // ← clear it. this matters.
}

If you only use .onChange, the window-was-closed case silently does nothing: the value was set before the view existed, so there’s no “change” to observe — .task is your only hook there. If you only use .task, the window-already-open case does nothing: the view’s already mounted, .task already ran.

You need both. They cover disjoint timelines.

Why the clear is load-bearing

router.pendingSection = nil after consuming isn’t tidiness — it’s correctness. Without it:

1. You click “Security” in the popover → window opens on Security. Good.

2. You close the window.

3. A week later you reopen the window normally (from the Dock, not a popover card).

4. .task fires, finds the stale pendingSection still pointing at Security, and yanks you to Security instead of your default tab.

Clearing on consume makes the destination strictly one-shot.

The takeaway

When two SwiftUI scenes need to talk and one of them might not be alive yet, don’t look for a direct channel — there isn’t one. Put the intent in shared observable state, and have the receiver drain it both on appearance (for the just-created case) and on change (for the already-alive case). Then clear it, so intent doesn’t outlive its moment.

It’s the same idea as a message queue with at-most-once delivery, shrunk down to a single @Observable property. Sometimes the smallest abstraction is the right one.

The headline: in-app file preview. Hit Space (or ⌘Y) on any file and it opens right inside the window — no bouncing to a separate panel:

• Source code with full syntax highlighting, across dozens of languages, themed for light & dark

• Markdown rendered formatted on a clean background

• Images, PDFs and media in a native in-window preview

A proper Finder-style toggle — Space opens and closes, Esc dismisses.

Also new: a Sponsor link in the Help menu + About tab if you’d like to back development, and the What’s New panel now shows on every update.

Free, notarized, universal (Apple Silicon + Intel), macOS 15+.

👉 https://findergit.app

Two additions that close the loop between watching (what v0.14.0 widened) and noticing (what’s actually waiting for your attention). One feature lands on screen, one in your macOS notification center; both keep octoscope read-only.

Review-requests inbox

The PRs tab now shows a sticky “PRs awaiting your review” section above your authored list — whenever someone has requested you as a reviewer. Same partition idiom as Repos pinned/watched (v0.13/v0.14): muted rule separator between segments, cursor walks both, sort cycle only re-orders the authored half (review-requests stay in GitHub’s UPDATED_AT DESC order), filter applies to both.

Section is absent when count == 0 — no rule, no header, the tab looks identical to pre-v0.15.0 if no one’s waiting on you. Discovery is via the README, not visual noise.

One GraphQL search call (review-requested:@me), gated on viewer mode (no point asking GitHub for someone else’s inbox), running in parallel with the rest of the dashboard refresh. Drilling in opens the full PR detail (v0.11.0 surface with v0.12.0 syntax-highlighted diff viewer) with the requester’s login visible.

macOS notification subtitle

Stars/followers change notifications now carry a second line — Stars, Followers, or Stars & Followers when both moved at once. Two wins:

- The Notification Center keeps per-entry timestamps visible even when terminal-notifier groups notifications. Without the subtitle, grouped notifications collapse and only the most recent shows when it arrived.

- The banner gains a visible category line under the title, useful when you spot the banner after the body has already scrolled past.

Upgrade

brew upgrade gfazioli/tap/octoscope

Or grab a binary from the release page: https://github.com/gfazioli/octoscope/releases/tag/v0.15.0

As always: read-only, free, MIT, on Linux / macOS / Windows. Source: https://github.com/gfazioli/octoscope

How do you split your day between “PRs you authored” and “PRs you’re meant to review”?

Curious if anyone has a watch_repos config they curated specifically because they review for a team there.

Hey there,

Welcome to the very first Netfox newsletter. If you’re reading this, you probably care about knowing what’s happening on your home network — without handing your data to someone else’s cloud. That’s exactly why Netfox exists.

What is Netfox?

Netfox is a native macOS network monitor. Open it, and you see every device on your local network — Apple gadgets, smart TVs, IoT sensors, printers, guest phones — in one live window.

It combines five discovery protocols (Bonjour, ARP, SSDP, NetBIOS, and active probing) so it catches devices that single-protocol scanners miss. Every device gets a full history: first seen, last seen, every online/offline transition, every IP or hostname change. That timeline persists across launches.

Five types of alerts keep you informed: new device, returning after long absence, risky arrival, port-state change, new service discovered.

And a one-click Security Scan checks common ports on every reachable device, with findings explained in plain English — no sysadmin log to decode.

It’s built 100% in SwiftUI for macOS 15+. No Electron, no web views. No cloud, no account, no telemetry. Your data stays on your Mac.

It’s free.

We’re on Product Hunt

This week I launched Netfox on Product Hunt, and the response has been incredible. We’ve already collected 86 upvotes and 68 followers — and the feedback from the community has been genuinely helpful.

If you haven’t yet, I’d really appreciate your support:

👉 Vote for Netfox on Product Hunt

Every upvote helps more people discover Netfox.

What’s in v0.3.2

The current release is v0.3.2. You can download it directly from the Netfox website or from the GitHub releases page:

🔗 https://netfox.app
🔗 https://github.com/gfazioli/netfox-website/releases/latest

What’s next

This is just the beginning. I’m actively working on new features and improvements — and this newsletter is where you’ll hear about them first.

Got ideas? Found a bug? I want to hear from you. Reply to this email or open an issue on GitHub:

🔗 https://github.com/gfazioli/netfox-website/issues

Thanks for being here from day one.

Star history sparkline ⭐

A 12-month star-history sparkline lands in the Repos drill-in: ASCII blocks ▁▂▃▄▅▆▇ over 52 weekly buckets, with empty weeks rendered as muted · ticks so the timeline stays continuous even on young repos. Footer reads +N in last 12mo · last star Xd ago. Fetched in parallel with the rest of the drill-in — no extra wait when you open a repo.

Latest release column

A new Release column on the Repos tab shows the most recent release tag plus its age (v1.2.3 · 3d). The s sort cycle gains a “release” entry. No extra round-trip — piggybacked onto the existing parallel CI query.

👀 Watched repos (external)

Add to your config:

watch_repos = [
  "charmbracelet/bubbletea",
  "cli/cli",
]

…and octoscope renders a dedicated Watched section under the Repos tab, separated from your owned repos by a muted rule. Same row idiom — CI dot, language, stars, latest release column — but populated from the GraphQL API in parallel with the dashboard refresh. Bounded fan-out (cap 10) so a long config doesn’t burst-flood GitHub.

Theme fidelity — monochrome means monochrome

The monochrome, phosphor and amber themes used to leak external semantic colour (GitHub language palette, CI rollup green/red, Activity heatmap gradient) even though they explicitly promise zero chroma. This release closes that gap end-to-end: language bars rank-scale through the theme’s own palette, CI rollup uses distinct glyphs (✓ / ✕ / ⋯ / ·) instead of colour, the Activity heatmap routes through the theme’s gradient. The promise on the theme name finally means what it says.

Upgrade

brew upgrade gfazioli/tap/octoscope

Or grab a binary from the release page: https://github.com/gfazioli/octoscope/releases/tag/v0.14.0

As always: read-only, free, MIT, on Linux / macOS / Windows. Source: https://github.com/gfazioli/octoscope

What would you put in your watch_repos?
Curious if anyone uses it for “my team’s repos” vs “projects I follow personally” — the answer shapes what gets a dedicated card next.

Introduction

Imagine you’re building a landing page. The hero needs a looping background video. The product section needs an inline player with a clean control bar. And somewhere on the page, there’s a feature demo where you want a completely custom UI — circular play button, vertical timeline, custom seek preview. With the native HTML <video> element, that’s three different implementations, each with its own quirks and audio glitches. With @gfazioli/mantine-video, it’s one component, three patterns, zero compromises.

What is mantine-video?

@gfazioli/mantine-video is a video player for React applications built with Mantine 9 and React 19. It wraps the native HTML <video> element with three layers of abstraction, layered from “drop-in” to “fully custom”:

1. <Video /> — a fully themed, batteries-included player that works out of the box.

2. A compound API (Video.Controls, Video.PlayButton, Video.Timeline, …) for composable control bars.

3. useVideo headless hook — full state and actions for building a 100% custom UI on top of a plain <video> element.

Every part is theme-aware (color scheme, Mantine theme colors, radii, sizes), accessible (ARIA labels, keyboard shortcuts, focus management), and customizable through the full Mantine Styles API. Four variants — overlay, minimal, floating, bordered — cover the most common layouts out of the box. Picture-in-Picture, fullscreen, captions and live timeline scrubbing are wired in by default.

Oh, and the same player can also be a background video. More on that below.

✨ Key Features

A polished default player

The fastest path: pass src, optionally poster and aspectRatio, and you have a complete player with play/pause, scrubbable timeline, time display, volume control, captions toggle, Picture-in-Picture and fullscreen.

import { Video } from '@gfazioli/mantine-video';

function Demo() {
  return (
    <Video
      src="https://example.com/video.mp4"
      poster="https://example.com/poster.jpg"
      aspectRatio={16 / 9}
    />
  );
}

Compound API for custom control bars

The default control bar is just a sensible composition of compound sub-components. Pass controls={false} and bring your own children to reorder, remove, or add controls — without losing Mantine theming or accessibility.

<Video src="..." aspectRatio={16 / 9} controls={false}>
  <Video.Controls>
    <Video.PlayButton />
    <Video.SkipButton seconds={-10} />
    <Video.SkipButton seconds={10} />
    <Video.Timeline />
    <Video.TimeDisplay format="current/-remaining" />
    <Video.MuteButton />
    <Video.CaptionsButton />
    <Video.PiPButton />
    <Video.FullscreenButton />
  </Video.Controls>
</Video>

Nine compound sub-components available: Video.Controls, Video.PlayButton, Video.SkipButton, Video.Timeline, Video.TimeDisplay, Video.MuteButton, Video.CaptionsButton, Video.PiPButton, Video.FullscreenButton.

Headless useVideo hook

When the compound API isn’t flexible enough, skip the <Video /> component entirely and use the useVideo hook with a plain <video> element. You get full state plus a complete set of actions.

import { ActionIcon, Slider } from '@mantine/core';
import { IconPlayerPauseFilled, IconPlayerPlayFilled } from '@tabler/icons-react';
import { useVideo } from '@gfazioli/mantine-video';

function CustomPlayer() {
  const video = useVideo();

  return (
    <div>
      <video ref={video.videoRef} src="..." />
      <ActionIcon onClick={video.toggle}>
        {video.playing ? <IconPlayerPauseFilled /> : <IconPlayerPlayFilled />}
      </ActionIcon>
      <Slider
        value={video.currentTime}
        max={video.duration}
        onChange={video.seek}
      />
    </div>
  );
}

The hook exposes 16 state values (playing, paused, ended, currentTime, duration, buffered, volume, muted, playbackRate, fullscreen, pip, isLoading, error, canPlay, canFullscreen, canPiP) and 16 actions (play, pause, toggle, seek, seekBy, setVolume, mute, unmute, toggleMute, setPlaybackRate, requestFullscreen, exitFullscreen, toggleFullscreen, requestPiP, exitPiP, togglePiP) plus the two refs (videoRef, containerRef).

Live timeline scrubbing

Drag the timeline thumb — the underlying <video> seeks in real time and you see the frame update under your finger, YouTube-style. The player pauses automatically during the drag and resumes on release if it was playing. Throttled with requestAnimationFrame so it stays smooth even on heavier videos. Opt out with <Video.Timeline liveScrub={false} /> to fall back to commit-on-release.

Four built-in variants

<Video src="..." variant="overlay" />    {/* default — YouTube-style overlay */}
<Video src="..." variant="minimal" />    {/* controls below the video, page flow */}
<Video src="..." variant="floating" />   {/* controls in a glass-morphism card */}
<Video src="..." variant="bordered" />   {/* bordered frame for cards/lists */}

Each variant changes only the position and styling of the controls — the API and sub-components stay identical.

Background video — one prop turns the player into a hero

This is where the layered API really pays off. Set asBackground and the same player becomes an absolute-positioned, cover-cropped element ready to drop inside any hero section.

<Box pos="relative" h="100vh">
  <Video src="..." asBackground autoPlay muted loop />
  <Title>Welcome to my product</Title>
  {/* Your hero content overlaid on top */}
</Box>

When asBackground is on, the component:

• Positions itself absolutely (position: absolute; inset: 0) inside its parent

• Applies object-fit: cover on the underlying <video>

• Disables controls, clickToToggle, shortcuts and autoHideControls as defaults (you can still re-enable any of them explicitly)

• Renders a discreet floating mute toggle in the bottom-right corner, controllable via the backgroundMuteButton prop

For finer control, the standalone fit prop accepts 'cover' | 'contain' | 'fill' | 'none' | 'scale-down' and maps directly to CSS object-fit.

Picture-in-Picture

PiP is wired in by default. The browser’s native always-on-top window can be launched via:

• The <Video.PiPButton /> — auto-hides on browsers without the standard API (notably Firefox)

• The P keyboard shortcut

• Programmatically via useVideo().togglePiP()

Plus two lifecycle callbacks to react to the user popping the video out:

<Video
  src="..."
  onEnterPictureInPicture={() => console.log('PiP open')}
  onLeavePictureInPicture={() => console.log('PiP closed')}
/>

Keyboard shortcuts

When shortcuts is enabled (default) and the player has focus:

• Space / K — toggle play / pause

• J / L — seek -10s / +10s

• ← / → — seek -5s / +5s

• ↑ / ↓ — volume up / down

• M — mute toggle

• F — fullscreen toggle

• P — Picture-in-Picture toggle

🚀 Getting Started

npm install @gfazioli/mantine-video
# or
yarn add @gfazioli/mantine-video

Import the styles at the root of your application:

import '@gfazioli/mantine-video/styles.css';

A layered version is also available under @layer mantine-video for fine-grained cascade control:

import '@gfazioli/mantine-video/styles.layer.css';

Then drop it anywhere:

import { Video } from '@gfazioli/mantine-video';

export function Demo() {
  return (
    <Video
      src="https://example.com/video.mp4"
      poster="https://example.com/poster.jpg"
      aspectRatio={16 / 9}
    />
  );
}

Props & API

The <Video /> component accepts a rich set of props grouped by responsibility:

Source & playback

• src: string — video source URL

• poster: string — image displayed before playback starts

• autoPlay, muted, loop, playsInline, preload — forwarded to the underlying <video>

• playing / currentTime / volume / playbackRate — controlled props with matching onPlayChange / onCurrentTimeChange / onVolumeChange / onPlaybackRateChange callbacks

Look & feel

• variant: 'overlay' | 'minimal' | 'floating' | 'bordered'

• color: MantineColor

• radius: MantineRadius

• size: MantineSize

• aspectRatio: number — e.g. 16 / 9

Interactivity

• controls: boolean — render the default control bar (default true)

• clickToToggle: boolean — click anywhere on the video to play / pause

• doubleClickToFullscreen: boolean

• shortcuts: boolean — enable keyboard shortcuts when focused

• autoHideControls: number — ms of inactivity before controls fade out (0 disables)

Background mode

• asBackground: boolean — preset for hero / section backgrounds

• backgroundMuteButton: boolean — floating mute toggle when asBackground is on (default true)

• fit: 'cover' | 'contain' | 'fill' | 'none' | 'scale-down' — CSS object-fit on the <video>

Lifecycle callbacks

• onEnded() — playback reached the end of the media

• onError(error: MediaError | null)

• onEnterPictureInPicture() / onLeavePictureInPicture()

• onFullscreenChange(fullscreen: boolean)

🎨 Styling

<Video /> supports the full Mantine Styles API. Every sub-part is targetable through classNames, styles, vars and unstyled props.

Selectors: root, video, controls, controlBar, playButton, timeline, timelineBuffered, timeDisplay, muteButton, fullscreenButton, pipButton, captionsButton, skipButton, iconButton, backgroundMuteButton.

CSS variables: --video-color, --video-radius, --video-bg, --video-controls-bg, --video-controls-height, --video-controls-text-color, --video-timeline-color, --video-timeline-thumb-color, --video-object-fit.

<Video
  src="..."
  classNames={{ playButton: 'my-play-button' }}
  styles={{ controls: { background: 'transparent' } }}
  vars={() => ({
    root: { '--video-color': 'tomato' } as Record<string, string>,
  })}
/>

Live Demo & Documentation

The docs site at gfazioli.github.io/mantine-video ships with ten interactive demos covering every API surface — an interactive configurator, the basic player, custom controls, each of the four variants, headless usage via useVideo, Picture-in-Picture lifecycle, and the Styles API playground.

There are also two full-bleed standalone pages that show the asBackground mode in real landing-page scenarios:

• fullscreen — a single immersive hero with title + CTA over a looping video

• homepage — a multi-section landing page that alternates three different background videos with text content and a features grid

Links

• 📦 npm: @gfazioli/mantine-video

• 📖 Documentation & demos

• 🔗 GitHub repository

• 🧩 Mantine Extensions Hub

The problem

If you work on GitHub every day, you probably know the dance. You’re deep in a coding session, you want to glance at “how many PRs are open on my repos right now”, or “did that follower count tick up after the release post”, or “which of my repos did I last push to”. So you tab over to the browser, wait for the page to load, click through to a sub-view, squint at the numbers, and tab back. Thirty seconds later you’ve lost your place in the code.

The data itself is trivial. It’s the context switch that’s expensive.

The solution

octoscope is a terminal dashboard for your GitHub account — profile, repos, pull requests, issues, contribution activity — pulled from the GitHub GraphQL API in a single round-trip and kept on screen, auto-refreshed every 60 seconds. You run it once in a background terminal tab and it’s always there when you need it.

Single binary. Cross-platform (macOS, Linux, Windows). No runtime dependencies. No config file. If you have a shell, you can run octoscope.

octoscope

That’s it. If you have a GitHub token in your environment, it detects it and renders your own dashboard. If not, you can pass any public username as an argument:

octoscope torvalds

What it shows

The UI is split into five tabs, navigable with number keys 1–5 or tab / shift+tab. The profile header stays pinned at the top; only the body swaps.

Overview — the landing page

The classic dashboard: profile info (name, login, pronouns, bio, company, location, website, years on GitHub), a Social section (followers, following, stars received), an Activity section (lifetime PRs authored and merged, issues opened, commits in the last 12 months, plus a languages bar coloured with the same hex GitHub uses on the site), an Operational section (public repos, forks received, open issues, open PRs), and a Network section (organisations you’re in, verified social accounts).

Repos — every repository in one list

Every owned, non-fork repository as a sortable, searchable table. Columns: name, primary language, stars, forks, open issues, open PRs, last push. Press s to cycle sort by any column, / to filter by substring. The viewport scrolls, so even a 100-repo account stays navigable.

PRs — every pull request you’ve opened

Every open pull request you’ve authored, across every repo you’ve ever touched — not just your own. Number, title, repo, state (draft / ready-to-merge / conflicting) and last-update time. Same sort & search idioms as Repos.

Issues — every open issue you’ve opened

Same shape as PRs, minus the state column. Every open issue you’ve authored, wherever it lives. The whole backlog in one keystroke.

Activity — your year, shaded

A 52-week contribution heatmap rendered on an accent-pink gradient, with month labels above and a summary line below: total contributions, current streak, longest streak, busiest day with its date. The gradient adapts to your own distribution, so the busiest day always hits the full neon pink regardless of your absolute volume.

The details that matter

Rate-limit awareness, live in the footer

GitHub’s GraphQL API has a 5,000-points-per-hour ceiling on authenticated calls. octoscope surfaces your remaining budget live in the footer:

Updated 12s ago  ·  rate 4872/5000  ·  reset 23m  ·  auto 60s

The chip is muted at normal levels, warn-yellow under 20% remaining, and error-red under 5%. No surprises when you’re close to the ceiling. If you do hit it, the auto-refresh backs off until the reset time instead of hammering every 60s and making it worse.

Fetch errors that tell you what to do

When a refresh fails, the footer says why in plain English:

• rate-limited · retry at 14:23 — bucket exhausted, here’s when it refills

• token rejected · check $GITHUB_TOKEN — auth problem, actionable

• offline · retrying — network blip

• github errored · retrying — 5xx from GitHub, wait it out

You know whether to wait, fix auth, or check the network — instead of staring at an opaque error indicator.

Live change feedback

When a value changes between two refreshes — a new star, a new follower, a PR merging — the affected card’s border flashes accent-pink for two seconds. No diffing numbers with your eyes.

And on top of that, changes to Stars and Followers trigger a native system notification and a short audio beep. You notice passive attention even when octoscope is in a background tab. macOS, Linux and Windows — no configuration needed.

Screenshot-safe by default when you want it

If you manage private repositories (work, internal projects, drafts) and you’re about to share a screenshot of your dashboard, one flag scrubs the output:

octoscope --public-only

Private repos, PRs and issues are filtered from the Repos / PRs / Issues tabs. Global counters (PRs Authored, Merged, Issues Authored) stay complete since they’re aggregate numbers, not titles. What gets hidden are repo names and PR/issue titles — the parts that actually leak context.

Authentication that just works

octoscope resolves a GitHub token in this order:

1. $GITHUB_TOKEN environment variable

2. gh auth token — if the GitHub CLI is installed and logged in

3. No token — unauthenticated fallback (60 req/h, public profiles only)

Viewing your own account needs a token. Viewing anyone else’s public profile works either way.

Getting started

Homebrew (macOS & Linux)

brew install gfazioli/tap/octoscope

From source (Go 1.25+)

go install github.com/gfazioli/octoscope@latest

Pre-built binaries

Grab the right archive for your platform from the latest release and drop the octoscope binary anywhere on your $PATH.

Key bindings

What octoscope won’t show

A note on honesty: some things you see on your GitHub profile page are not exposed by GitHub’s public API, so octoscope doesn’t show them either. Achievements (Pull Shark, Starstruck, YOLO and friends), highlight badges like PRO, and the local time next to your location field all require scraping the profile HTML. octoscope stays API-only, so those are absent by design.

Built with BubbleTea

octoscope is a terminal UI built with BubbleTea — the ELM-inspired TUI framework from Charm — and styled with Lipgloss. The network layer uses shurcooL/githubv4 against the GitHub GraphQL API, one round-trip per refresh.

The whole thing is open source under the MIT license.

Links

• 🌐 Landing: https://gfazioli.github.io/octoscope/

• 📦 GitHub: https://github.com/gfazioli/octoscope

• 📋 Releases: https://github.com/gfazioli/octoscope/releases

• 🐛 Issues & ideas: https://github.com/gfazioli/octoscope/issues

If you live in the terminal and you’re on GitHub every day, give it a spin. Feedback, bug reports and feature asks are genuinely shaping the roadmap — every issue ticket has been read.

A day with twelve repositories

Before. You have a ~/Projects folder with twelve Git repos in it. To know which ones are dirty, you open Terminal, cd into each, run git status, repeat. Or you open Tower and wait for it to scan. Or you open VS Code twelve times. None of this is looking at your files — it’s ceremony around looking at your files.

After. You open FinderGit and the folder tree looks like Finder’s list view, plus four columns: branch name, clean/dirty/unpushed badge, number of changed files, and sizes and dates. Directories inside a dirty repo get a small orange dot with a count — so you spot modifications three levels deep without expanding anything.

That’s the whole pitch. The rest of this post is the details.

What is FinderGit?

FinderGit is a native macOS app built with SwiftUI. It’s positioned somewhere between Finder and a heavy Git client like Tower — it’s not a replacement for either. If your day involves interactive rebases, submodule surgery, or cherry-picking across a long history, you’ll still want Tower, GitX, or your CLI.

FinderGit is for the other 90% of the day: the part where you’re browsing your projects, quickly checking “what did I leave dirty yesterday?”, staging a few files, typing a commit message, pushing. Everything happens in the window that already shows your files — no context switch.

It runs on macOS 15 Sequoia or later. It’s free, open-source (the website repo is public, the app repo will follow), and this is the public beta — v0.1.0. Expect a few rough edges; file them, I fix them.

✨ Key features

• Tree view with sortable columns — Finder-style list view, but the columns are Name, Branch, Status, Changes, Size, Date Modified. Click any header to sort.

• Live Git status per repository — a small badge next to each repo: CLEAN (green), DIRTY (orange), UNPUSHED (blue). Updates in real time via FSEvents.

• Sub-directory dirty indicators — directories inside a repo show an orange dot with the number of modified files they contain. Walk down to the changes without expanding every folder.

• Inline diff viewer — click any modified file and the right pane renders a unified diff with green/red lines, hunk headers, and line numbers. Supports HEAD, staged, unstaged, and even untracked files (rendered as all-added).

• Git actions from the UI — Stage, Unstage, Commit, Push, Pull, Fetch. Per file or per repo. Commit messages get a TextField and two buttons: Commit Staged or Commit All & Push.

• Native Markdown preview via Quick Look — press Space on any .md or .markdown file and it opens in a native renderer with a GitHub-style theme. Close with Space or Escape. Every other file type falls back to the system qlmanage, so you keep PDF, image, video previews for free.

• Smart context menus — right-click adapts to what you clicked: repo gets Fetch / Pull / Push / Stage All; tracked file gets Stage / Unstage; non-git directory gets Add as Root Folder; everything gets Open / Reveal in Finder / Copy Path / Open in Terminal.

• Multiple root folders — add as many as you want. Drop folders from Finder directly onto the sidebar; they become tree roots.

• Search & filter — type in the toolbar to filter the tree by name (300ms debounce). Toggle Git Only to hide everything that isn’t a repo — instant overview of just your projects.

• Keyboard-driven — ⌘⇧F Fetch, ⌘⇧L Pull, ⌘⇧P Push, ⌘⇧A Stage All, ⌘⇧S Stage selected, Space Quick Look, ⌘+/⌘- zoom, ⌘⇧R Reveal in Finder. The usual Mac muscle memory.

🛠 What’s powering it

For the developer-curious reader:

• Swift + SwiftUI, deployment target macOS 15. The UI uses NavigationSplitView with a native Table(children:) for the tree, so sorting, keyboard navigation and selection come from AppKit under the hood.

• Observation framework (@Observable) for state — no ObservableObject / @Published boilerplate. Structured concurrency (async/await) everywhere, no DispatchQueue.

• FSEvents via a small GitWatcher that observes both the worktree and .git/HEAD, .git/index, .git/refs/, .git/FETCH_HEAD — debounced at the user-configurable latency. So pushing in Terminal updates the FinderGit badge within milliseconds.

• git status --porcelain=v2 under the hood. /usr/bin/git is called via Process with a parser for the machine-readable output. No libgit2, no reimplementing history — the real git binary is the source of truth.

• MarkdownUI for the Markdown preview. Pattern is extensible — same “interceptor” will take .css / .js / .swift with syntax highlighting in a future release.

• Sparkle for auto-updates, EdDSA-signed. See below.

• Personal Team signing, no Apple Developer Program ($99/year) required. That has implications for Gatekeeper — covered in the install section.

📦 Install

Requirements

• macOS 15 (Sequoia) or later

• Xcode Command Line Tools — FinderGit uses the system git binary, which on macOS is shipped as a stub. On a fresh Mac, run once:

  xcode-select --install
  sudo xcodebuild -license

Without these, every Git action inside FinderGit returns nonZeroExit(status: 89, …). This will be surfaced as a friendly dialog in a future release — for now, the Terminal workaround is a one-time setup.

Download

1. Grab the latest .dmg from the GitHub Release.

2. Open it and drag FinderGit into your Applications folder.

First launch — Gatekeeper

The app is signed with a free Personal Team, not with an Apple Developer ID. That means macOS Gatekeeper doesn’t know it and will block the first launch with a generic warning. The fix is the standard Mac dance:

1. Open Applications in Finder.

2. Right-click on FinderGit.app → Open.

3. In the confirmation popup, click Open again.

Done once — from then on the app launches normally, including auto-updates. No paid developer program is funding this; you’re trading a 5-second first-launch gesture for a free app.

🔄 Auto-updates

FinderGit ships with Sparkle. The app checks https://findergit.app/appcast.xml on launch and periodically; when a new version is available, you get the standard Sparkle alert with release notes. Each release DMG is signed with an EdDSA key — the public key ships inside the app, so Sparkle refuses to install an update it cannot verify. Even if my GitHub account were compromised tomorrow, an attacker couldn’t push a malicious update without my private signing key.

You can also trigger a check manually via the FinderGit → Check for Updates… menu item.

🗺 What’s next

The beta is functional, but plenty is already planned. Highlights of the public issue tracker:

• Syntax highlighting in Quick Look for code files (.swift, .js, .ts, .py, .css, .json, …) — the Markdown interceptor pattern, extended.

• Double-click a folder to navigate into it (drill-down, with a breadcrumb to go back).

• Branch creation, renaming, deletion, checkout from the UI.

• Stash management (save, pop, apply, drop).

• GitHub / GitLab / Bitbucket providers — list Issues and Pull Requests for the current repo. Preference for gh / glab CLI when installed; REST fallback with a token in Keychain.

• Kaleidoscope integration — jump from the inline diff to the full Kaleidoscope comparison, à la Tower.

• AI-generated commit messages — a built-in ✨ AI button next to the commit text field that drafts a message from your staged diff, no external tools or API keys required.

• Auto-fetch on an interval wired to the setting that already exists.

• Drag files from the tree to external apps — without breaking row selection, which is why it’s not in v0.1.0.

If any of these are on your wish list, say so — priorities move.

Download, feedback, sponsorship

Three things, in order of how much they help:

1. Download it and try it → latest release. Ten minutes with real repos tells you more than any blog post.

2. Tell me what works and what doesn’t → open an issue on the website repo. Bug reports, feature requests, workflow pain points — all welcome. Screenshots help.

3. If it turns into something you rely on, consider sponsoring → GitHub Sponsors. FinderGit is free, unsigned by Apple, and maintained in evenings and weekends. Sponsorship keeps the momentum.

Links

• 🌐 Website & docs: findergit.app

• 📥 Download: GitHub Release v0.1.0

• 🐛 Issues & feedback: github.com/gfazioli/findergit-website/issues

• ⭐ Sponsor: github.com/sponsors/gfazioli

Back in 1991, I started writing what would become a 5,800-line shared library for the Commodore Amiga — entirely in hand-optimized Motorola 68020 assembly. The first routines (string utilities in libraries.asm) were saved on July 29, 1991. Over the next four years, the library grew steadily — graphics in October 1994, file I/O and memory management in early 1995, the REI windowing system through mid-1995, and the last recorded update in September 1995.

That code sat on floppy disks and hard drives for decades. Now, in 2026, I’ve dusted it off, open-sourced it, and built a modern documentation site for it with Next.js.

Let me tell you the story.

What Is This?

The Amiga Assembly Library is a shared library (assembly.library) for AmigaOS, written between 1991 and 1995, that provides 50+ high-level utility functions in optimized 68020 assembly. Think of it as a “standard library” for Amiga developers — covering everything from memory management and file I/O to bitmap graphics, string manipulation, and even a full windowing abstraction.

It’s Public Domain — no copyright, no licensing, no restrictions. Use it however you want.

Why Assembly? And Why Now?

When I wrote this library in the early ‘90s, the Amiga was my daily machine. I was 19, obsessed with squeezing every cycle out of the 68020, and frustrated by rewriting the same utility routines for every project. So I did what any obsessive programmer would do — I built a shared library.

The Amiga community, remarkably, is still alive and well in 2026. People are building hardware accelerators, writing new software, and pushing these machines beyond what anyone thought possible. When you’re working with a 7 MHz 68000 (or a 50 MHz 68060 if you’re lucky), every cycle counts. Hand-optimized assembly isn’t a flex — it’s a necessity.

I decided to open-source the library and give it the documentation it always deserved — because if this code helped me build a dozen projects in the ‘90s, maybe it can help someone else today.

What’s Inside?

The library is organized into 8 modules:

Exec — Memory and linked list management. AllocNewList, AllocNode, FreeList, ReAllocVec, and RevertMem for reversing memory regions.

DOS — File operations. Load and Save files to/from memory, FileInfo for metadata, CheckSum for data integrity, LineInput for reading files line by line, and UnitInfo for volume information.

Graphics — Bitmap rendering. Allocate and clone RastPorts, manage bitplanes dynamically, draw boxes and frames, and render printf-style formatted text directly to graphics surfaces.

Libraries — String utilities and media parsing. Case conversion, character filtering, AIFF/IFF chunk parsing, and ILBM image decompression.

Math — Number conversions between decimal, hex, binary strings and values — in both directions.

Intuition & GadTools — UI widgets. Custom dialog requesters with buttons, gadget property control by name (not just ID), and attribute manipulation.

REI Interface — This is the crown jewel. A complete windowing abstraction that separates UI definitions from application logic. You define your window layout in a .rei binary file, load it at runtime, and interact with named gadgets through an event-driven message loop. Think of it as a declarative UI system — for a 1990s computer.

C Interface — Full C prototypes and SAS/C pragma declarations so you can call every function from C with type safety.

The Magic of Auto-Opening

One of my favorite design decisions: when you open assembly.library, it automatically opens and caches 12+ system libraries for you:

#include <assembly/assemblybase.h>
#include <clib/assembly_protos.h>

struct AssemblyBase *AssemblyBase;

void main(int argc, char **argv)
{
    if (AssemblyBase = (struct AssemblyBase *)
        OpenLibrary(ASSEMBLYNAME, ASSEMBLY_MINIMUM))
    {
        /* All sub-libraries are now available:
         * AssemblyBase->ab_DosBase
         * AssemblyBase->ab_IntuiBase
         * AssemblyBase->ab_GfxBase
         * AssemblyBase->ab_GadToolsBase
         * AssemblyBase->ab_AslBase
         * ... and 7 more
         */

        CloseLibrary((struct Library *)AssemblyBase);
    }
}

One OpenLibrary call and you get graphics.library, intuition.library, dos.library, gadtools.library, asl.library, icon.library, workbench.library, datatypes.library, locale.library, lowlevel.library, realtime.library — all ready to use. No boilerplate. No forgetting to close one of them.

The REI Windowing System

The REI (Runtime External Interface) module deserves its own section. Instead of hardcoding window layouts in your application code, you define them in .rei files — binary interface definitions that describe windows, gadgets, menus, and their relationships.

At runtime, you load the .rei file and interact with UI elements by name:

OpenREI          → Create the window from a .rei file
WaitREIMsg       → Event-driven message loop
FindAsmGadget    → Find a gadget by its name
SetREIAttrs      → Change window properties
LockREI/UnlockREI → Thread-safe access
CloseREI         → Clean shutdown

The project even includes a visual REI Editor (v0.52) — a GUI tool for designing .rei files without writing code.

This approach is philosophically similar to what modern frameworks do with JSX or XML layouts. But this was designed for AmigaOS, running on a 68020.

The Documentation Site

Here’s where old meets new. The library documentation lives at amiga-assembly-library.vercel.app — a modern site built with:

• Next.js 15 with Nextra for MDX-based docs

• Mantine 9 for the UI components

• TypeScript 6 for type safety

• Syntax-highlighted 68020 assembly source code

• Complete API reference for all 50+ functions

• Example programs with full source

• An Amiga Mode toggle that applies retro styling

Yes, a documentation site built with React and TypeScript — for a 68020 assembly library. The irony is not lost on me.

Getting Started

Requirements

• CPU: Motorola 68020 or higher

• OS: AmigaOS with KickStart 3.0 (V39) or later

• Assembler: HiSoft DevPac or compatible

• C Compiler (optional): SAS/C, DICE, or compatible

Installation

Copy assembly.library to your LIBS: directory. That’s it — it’s a standard AmigaOS shared library, available system-wide to all applications.

Assembly Usage

        move.l  _AbsExecBase,a6
        lea     AssemblyName(pc),a1
        moveq   #ASSEMBLY_MINIMUM,d0
        jsr     _LVOOpenLibrary(a6)
        move.l  d0,_AssemblyBase
        beq     .error

        ; Use library functions...
        move.l  _AssemblyBase,a6
        jsr     _LVOAllocNewList(a6)

        ; Clean up
        move.l  _AbsExecBase,a6
        move.l  _AssemblyBase,a1
        jsr     _LVOCloseLibrary(a6)

C Usage

Include the headers, open the library, and call functions directly:

#include <assembly/assemblybase.h>
#include <clib/assembly_protos.h>
#pragma libcall AssemblyBase AllocNewList 1e 00

struct List *myList = AllocNewList();

What’s in the Source?

The library is about 5,800 lines of hand-optimized 68020 assembly across 8 modules:

Plus C headers, pragma declarations, example programs (including a screen grabber, a window inspector, and the visual REI editor), and comprehensive documentation.

Why Open Source This?

Because the Amiga community thrives on sharing. The best Amiga software was always the stuff people passed around on floppy disks, uploaded to Aminet, and shared freely. This library is Public Domain — not MIT, not GPL, not Apache. Public Domain. Take it, use it, modify it, sell it, whatever you want. No attribution required.

If even one person building an Amiga project finds a useful function in here, it was worth it.

Links

• Documentation: amiga-assembly-library.vercel.app

• Source Code: github.com/gfazioli/Assembly-Library

• Documentation Source: github.com/gfazioli/amiga-assembly-library

This code is over 30 years old. I wrote it when I was a teenager, on a machine with 2 MB of RAM. And somehow it still works, still compiles, and still does exactly what it was designed to do. There’s something deeply satisfying about that.

If you’re into retro computing, 68k assembly, or just appreciate the craft of writing software for constrained platforms — I’d love to hear from you. Drop a star on the repo, open an issue, or just say hi.

The Amiga isn’t dead. It’s just warming up.

Introduction

Remember the first time you used macOS Time Machine? That moment when your desktop peeled away into an infinite corridor of snapshots, and navigating through time suddenly felt physical. That spatial metaphor stuck with us. mantine-depth-select brings that same sense of depth to any selection UI in your React application — pricing plans, document versions, onboarding steps, or anything else where browsing through stacked content beats scrolling a flat list. It’s a single component with zero extra dependencies, built entirely on Mantine 8’s Styles API.

What is DepthSelect?

DepthSelect renders an array of items as a 3D stack of cards. The frontmost card is the active selection; cards behind it recede with progressive scale, vertical offset, opacity, and blur — all configurable per-level. When the user navigates (via keyboard, mouse wheel, trackpad swipe, click, or arrow controls), cards animate smoothly in and out of the stack with CSS transitions.

The component follows Mantine’s compound component pattern. Built-in arrow controls appear by default, but you can hide them and wire up your own UI through controlled value/onChange. It supports both string and numeric values, loop mode, and respects prefers-reduced-motion.

✨ Key Features

3D Perspective Stack

Each card in the stack receives progressive CSS transforms based on its depth. Four props control the effect:

<DepthSelect
  data={items}
  scaleStep={0.1}       // scale reduction per level (default)
  translateYStep={30}    // vertical offset in px per level
  opacityStep={0.15}     // opacity reduction per level
  blurStep={1}           // blur in px per level
  w={400}
  h={300}
/>

Cards that exit the stack (when navigating forward) animate toward the viewer with a scale-up and fade-out. Cards entering from behind animate in from the deepest visible position.

Multi-Input Navigation

Every common input method works out of the box:

• Keyboard: ArrowUp/ArrowDown to step through, Home/End to jump

• Mouse wheel / Trackpad: Scroll over the component to navigate (page scroll is blocked automatically). Disable with withScrollNavigation={false}

• Touch: Vertical swipe gestures for mobile

• Click: Click the second card (depth 1) to advance

• Controls: Built-in arrow buttons with optional label

Built-in Controls with controlsProps

The default controls sit to the right of the stack. You can reposition them, add a label, set a fixed width, change alignment, or swap the icons — all through a single controlsProps object:

<DepthSelect
  data={items}
  controlsPosition="left"
  controlsProps={{
    w: 100,
    justify: 'end',
    labelFormatter: (item) => `Step ${item.value}`,
    upIcon: <IconChevronUp size={16} />,
    downIcon: <IconChevronDown size={16} />,
  }}
  w={400}
  h={300}
/>

Compound Component Pattern

Need full layout control? Set withControls={false} and use DepthSelect.Controls as a child:

<DepthSelect data={items} withControls={false} w={400} h={300}>
  <DepthSelect.Controls labelFormatter={(item) => String(item.value)} />
</DepthSelect>

Or skip the built-in controls entirely and build your own navigation with value and onChange.

Loop Mode

Enable loop to let navigation wrap from the last item back to the first (and vice versa). The arrow controls never show a disabled state in loop mode:

<DepthSelect data={items} loop w={400} h={200} />

🚀 Getting Started

npm install @gfazioli/mantine-depth-select

Import the styles at the root of your application:

import '@gfazioli/mantine-depth-select/styles.css';

Minimal example:

import { Card, Text } from '@mantine/core';
import { DepthSelect, DepthSelectItem } from '@gfazioli/mantine-depth-select';

const data: DepthSelectItem[] = [
  { value: 'first', view: <Card p="lg" withBorder h="100%"><Text>First item</Text></Card> },
  { value: 'second', view: <Card p="lg" withBorder h="100%"><Text>Second item</Text></Card> },
  { value: 'third', view: <Card p="lg" withBorder h="100%"><Text>Third item</Text></Card> },
];

function Demo() {
  return <DepthSelect data={data} w={400} h={200} />;
}

The w and h props define the area where cards live. Cards should use h="100%" to fill the available height.

Props & API

DepthSelect

• data — DepthSelectItem[] — Array of { value, view } objects. value can be string or number, view is any ReactNode

• value / defaultValue / onChange — Standard controlled/uncontrolled pattern

• w / h — Dimensions of the card area (passed to the inner stack container)

• visibleCards — Number of cards visible in the stack (default: 4)

• withControls — Show built-in arrow controls (default: true)

• controlsPosition — "right" (default) or "left"

• controlsProps — All DepthSelectControlsProps passed to the built-in controls

• loop — Enable wrap-around navigation (default: false)

• withScrollNavigation — Enable mouse wheel / trackpad navigation (default: true)

• transitionDuration — Animation duration in ms (default: 400)

• scaleStep / translateYStep / opacityStep / blurStep — Per-level depth effect parameters

DepthSelect.Controls

• labelFormatter — (item: DepthSelectItem) => ReactNode — Custom label between arrows

• upIcon / downIcon — Custom icons for the arrow buttons

• justify — Vertical alignment: "start", "center" (default), "end"

• Plus all Mantine BoxProps (w, h, style, etc.)

🎨 Styles API

Selectors: root, stack, card, controls, controlUp, controlDown, controlLabel

Data attributes:

• data-active — Frontmost (selected) card

• data-depth="N" — Card depth level (0 = front)

• data-exited — Card that has animated out

• data-disabled — Disabled control button

• data-controls-position — "right" or "left" on root

CSS variables: --ds-transition-duration, --ds-scale-step, --ds-translate-y-step, --ds-opacity-step, --ds-blur-step, --ds-visible-cards

⚡ Performance

• Render window: Only activeIndex - 1 through activeIndex + visibleCards + 1 are in the DOM. A dataset of 100 items renders ~6 nodes

• Memoized styles: Card CSS is computed once per navigation change via useMemo

• Targeted will-change: Only visible cards get GPU layer promotion; hidden cards use will-change: auto

• Non-passive wheel listener: Blocks page scroll without layout thrashing

• prefers-reduced-motion: Transitions are disabled automatically for users who prefer reduced motion

Live Demo & Documentation

Explore interactive demos — including a configurator with live props, rich card examples, pricing plan selector, version history browser, onboarding wizard, and more:

gfazioli.github.io/mantine-depth-select

Links

• 📦 npm: @gfazioli/mantine-depth-select

• 📖 Docs: gfazioli.github.io/mantine-depth-select

• 🔗 GitHub: github.com/gfazioli/mantine-depth-select

• 🧩 Mantine Extensions: mantine-extensions.vercel.app

Introduction

Version 1.0.0 of @gfazioli/mantine-border-animate is a major release that reimagines how animated borders work. The beam effect — the heart of the component — now ships with two distinct rendering modes, letting you choose between pixel-perfect border tracing and smooth conic rotation. Combined with new multi-color gradients, hover pause, custom easing, and built-in accessibility, this release makes animated borders more flexible, more beautiful, and easier to use than ever.

What’s New

Two Beam Rendering Modes

The biggest addition in v1.0 is the beamMode prop, which lets you choose how the beam effect is rendered:

Path mode (beamMode="path", the new default) uses CSS offset-path to move a radial-gradient circle along the component’s border. The beam maintains a uniform size at every position and travels at constant speed along the perimeter. This is the best choice for most UI elements.

<BorderAnimate beamMode="path" size="md" duration={5}>
  <Card>Your content</Card>
</BorderAnimate>

Conic mode (beamMode="conic") uses a rotating conic-gradient wedge animated via CSS @property. The rotation is buttery smooth, and the size prop controls the angular spread of the wedge (from a tight 18-degree spotlight at xs to a full 180-degree sweep at xl). It works best on circular or near-square elements.

<BorderAnimate beamMode="conic" size="lg" duration={3}>
  <Avatar radius="100%" />
</BorderAnimate>

Multi-Color Gradients with colorStops

Move beyond two-color gradients. The new colorStops prop gives you full control over the beam’s colors:

<BorderAnimate
  colorStops={[
    { color: 'transparent', position: 0 },
    { color: 'green', position: 20 },
    { color: 'cyan', position: 40 },
    { color: 'yellow', position: 60 },
    { color: 'red', position: 80 },
    { color: 'transparent', position: 100 },
  ]}
>
  <Paper>Multi-color beam</Paper>
</BorderAnimate>

colorStops works with both beam modes:

• Path mode generates a radial-gradient with concentric color rings

• Conic mode generates a custom conic-gradient — use transparent stops for beam/wedge effects, or fill the entire circle for a rotating rainbow border

Pause on Hover

Interactive elements often need the animation to pause during user interaction. The new pauseOnHover prop does exactly that — using pure CSS animation-play-state with zero JavaScript overhead:

<BorderAnimate pauseOnHover>
  <Button>Hover me to pause</Button>
</BorderAnimate>

Custom Timing Functions

Fine-tune animation feel with timingFunction. By default, beam uses linear and glow/pulse use ease-in-out, but you can override with any CSS timing function:

<BorderAnimate timingFunction="ease-in-out" />
<BorderAnimate timingFunction="cubic-bezier(0.4, 0, 0.2, 1)" />
<BorderAnimate timingFunction="steps(8)" />  {/* retro pixel effect */}

Accessibility Out of the Box

BorderAnimate now respects prefers-reduced-motion automatically. Users who have enabled “Reduce motion” in their OS settings will see no animations — no configuration needed, no extra props. It just works.

Breaking Changes

This is a major release with several breaking changes. Here’s what you need to update:

gradient variant removed

The gradient variant is gone. Use beamMode="conic" with full colorStops instead:

// v0.x
<BorderAnimate variant="gradient" colorFrom="red" colorTo="blue" />

// v1.0
<BorderAnimate
  beamMode="conic"
  colorStops={[
    { color: 'red', position: 0 },
    { color: 'blue', position: 50 },
    { color: 'red', position: 100 },
  ]}
/>

opacity renamed to borderOpacity

The old opacity prop conflicted with the CSS opacity property inherited from Mantine’s BoxProps. It’s now borderOpacity:

// v0.x
<BorderAnimate opacity={0.5} />

// v1.0
<BorderAnimate borderOpacity={0.5} />

anchor and count props removed

Both props have been removed with no direct replacement. Simply remove them from your components.

size semantics changed

The size prop now behaves differently depending on beamMode:

• Path mode: still pixel-based (xs=64px to xl=480px) — same as v0.x

• Conic mode: angular spread of the wedge (xs=18 degrees to xl=180 degrees)

BorderAnimateVariant type updated

The type changed from 'beam' | 'glow' | 'gradient' | 'pulse' to 'beam' | 'glow' | 'pulse'. Update any type assertions or switch statements in your code.

Improvements

• Glow z-index fix — the glow variant now correctly renders behind content, preventing the overlay from obscuring text

• Accurate demos — all documentation demos now show code that exactly matches the rendered output

• New exported types — BorderAnimateBeamMode, BorderAnimateColorStop, and BorderAnimateVariant are now properly exported for consumers

Getting Started

Install or update:

npm install @gfazioli/mantine-border-animate@1

Import styles at the root of your application:

import '@gfazioli/mantine-border-animate/styles.css';

Basic usage:

import { BorderAnimate } from '@gfazioli/mantine-border-animate';

function Demo() {
  return (
    <BorderAnimate>
      <Paper withBorder p="md" radius="md">
        Your content with an animated border
      </Paper>
    </BorderAnimate>
  );
}

Links

• npm package

• Documentation and Demos

• GitHub Repository

• Mantine Extensions Hub

Introduction

Version 3.0.0 of @gfazioli/mantine-rings-progress is a ground-up rewrite. The internal fork of Mantine’s RingProgress has been completely removed, replaced by the native component from @mantine/core. This eliminates ~600 lines of custom SVG and animation code while adding 10 new features that bring the component closer to the Apple Watch activity rings experience.

Whether you’re building fitness dashboards, goal trackers, or compact data visualizations, this release gives you the tools to make your rings shine — literally.

✨ New Features

Per-ring Customization

Each ring can now override global props individually. Mix thick and thin rings, toggle round caps per ring, or set a custom background track color:

const rings = [
  { value: 40, color: 'cyan', thickness: 18 },
  { value: 65, color: 'red', thickness: 10, roundCaps: false },
  { value: 90, color: '#f90', thickness: 6, rootColor: 'gray' },
];

<RingsProgress size={180} rings={rings} />

Supported per-ring overrides: thickness, roundCaps, rootColor, glowIntensity, glowColor, ariaLabel, tooltip.

Staggered Entrance Animation

Instead of all rings appearing at once, use staggerDelay to animate them one after another — outer ring first, inner ring last:

<RingsProgress animate staggerDelay={300} transitionDuration={1000} rings={rings} />

Glow / Neon Effect

Add a neon-like glow that follows the ring shape using CSS drop-shadow. Set glow={true} for a default 6px blur, or pass a custom radius. Each ring can override the effect with glowIntensity and glowColor:

<RingsProgress glow={8} rings={rings} />

Pulse on Completion

When a ring reaches 100%, trigger a satisfying scale + brightness pulse animation — inspired by the Apple Watch ring closure celebration:

<RingsProgress pulseOnComplete rings={rings} />

The animation respects prefers-reduced-motion and uses a data-pulsing attribute for CSS customization.

onRingComplete Callback

Run custom logic when a ring crosses the 100% threshold:

<RingsProgress
  onRingComplete={(index, ring) => {
    showNotification({ message: `${ring.color} ring completed!` });
  }}
  rings={rings}
/>

Start Angle & Direction

Control where rings start filling and in which direction:

<RingsProgress startAngle={90} direction="counterclockwise" rings={rings} />

startAngle={0} is the 12 o’clock position (default). Direction accepts 'clockwise' or 'counterclockwise'.

Unified Tooltip

The new withTooltip prop shows a single, chart-style tooltip with color swatches for all rings — no more overlapping per-ring tooltips:

<RingsProgress
  withTooltip
  rings={[
    { value: 20, color: 'green', tooltip: 'Fitness – 40 Gb' },
    { value: 80, color: 'blue', tooltip: 'Running – 50 min' },
  ]}
/>

If tooltip is not set on a ring, the percentage value is shown automatically.

Accessibility

The component is now fully accessible out of the box:

• Root element: role="group" with aria-label="Progress rings" (overridable)

• Each ring: role="progressbar" with aria-valuenow, aria-valuemin, aria-valuemax

• Per-ring ariaLabel for custom screen reader text

• Automatic prefers-reduced-motion support via useReducedMotion

💥 Breaking Changes

This is a major release with breaking changes. Here’s what you need to update:

Animation props renamed/removed

  <RingsProgress
-   animationDuration={1000}
-   animationSteps={60}
-   animationTimingFunction="ease"
+   transitionDuration={1000}
    animate
    rings={rings}
  />

• animationDuration → transitionDuration (default changed from 1000 to 0)

• animationSteps — removed (CSS transitions replaced JS setInterval)

• animationTimingFunction — removed (CSS uses ease by default)

Tip: If you only use animate for entrance animation, you can omit transitionDuration entirely — the component auto-applies 1000ms during the entrance phase.

Ring type changed

- import { RingProgressSection } from '@gfazioli/mantine-rings-progress';
- const rings: RingProgressSection[] = [...]
+ import { RingsProgressRing } from '@gfazioli/mantine-rings-progress';
+ const rings: RingsProgressRing[] = [...]

The base properties (value, color, tooltip) remain the same, so existing code that only uses those will work without changes.

Props interface

RingsProgressProps now extends BoxProps + StylesApiProps + ElementProps<'div'> (standard Mantine pattern) instead of the forked RingProgressProps. All common props (size, thickness, roundCaps, label, animate) are still available.

Styles API

A new 'label' style name was added. Style names are now 'root' | 'ring' | 'label'.

🔧 Improvements

Drastically simplified internals

The entire forked RingProgress/ directory (~600 lines) has been deleted. The component now delegates entirely to Mantine’s native RingProgress, ensuring better compatibility with future Mantine releases and smaller bundle size.

Smart entrance animation

The component auto-applies 1000ms transition during the entrance phase only. After all rings mount, transitionDuration reverts to 0 — preventing geometry changes (like resizing) from triggering unwanted CSS transitions.

Interactive demos

The documentation now includes replay buttons for animation demos, interactive sliders for the pulse demo, and a configurator with all new props.

🐛 Bug Fixes

• Label centering: Fixed the label being offset from center — now rendered as a separate overlay

• Debug styles: Removed hardcoded color: 'red' on the label

• Theme overrides: Fixed useProps('Rings', ...) → useProps('RingsProgress', ...)

• Countdown demo: Added transitionDuration={0} to prevent CSS transitions from interfering with rapid updates

Getting Started

npm install @gfazioli/mantine-rings-progress@3

Import styles at the root of your application:

import '@gfazioli/mantine-rings-progress/styles.css';

Basic usage with the new features:

import { RingsProgress } from '@gfazioli/mantine-rings-progress';

function ActivityRings() {
  const rings = [
    { value: 75, color: 'green', tooltip: 'Move' },
    { value: 50, color: 'blue', tooltip: 'Exercise' },
    { value: 90, color: 'orange', tooltip: 'Stand' },
  ];

  return (
    <RingsProgress
      size={180}
      rings={rings}
      animate
      staggerDelay={300}
      glow={6}
      withTooltip
      pulseOnComplete
      onRingComplete={(i) => console.log(`Ring ${i} done!`)}
    />
  );
}

Links

• 📦 npm package

• 📖 Documentation & Demos

• 🔗 GitHub Repository

• 🧩 Mantine Extensions Hub

Introduction

The Mantine QR Code component has been completely rebuilt from the ground up. What was previously an LED-style indicator has been transformed into a fully functional QR code generator that produces real, scannable codes from any string input. It renders pure SVG for crisp output at any resolution, follows Mantine’s Styles API conventions, and ships with a dedicated download hook for exporting to SVG, PNG, JPEG, or WebP.

✨ New Features

Real QR Code Generation

The component now encodes actual QR code data using the qrcode library. Pass any string — a URL, WiFi credentials, vCard, plain text — and get a scannable QR code rendered as optimized SVG.

import { QRCode } from '@gfazioli/mantine-qr-code';

function Demo() {
  return <QRCode value="https://mantine.dev" />;
}

The value prop is the only required prop. Everything else has sensible defaults.

Dot Styles

Control the appearance of data modules with the dotStyle prop. Three built-in styles are available:

<QRCode value="https://mantine.dev" dotStyle="square" />   {/* Default */}
<QRCode value="https://mantine.dev" dotStyle="rounded" />
<QRCode value="https://mantine.dev" dotStyle="dots" />

Each style generates a single combined <path> element for all data modules, keeping the DOM lightweight even for dense QR codes.

Corner Styles

The three finder patterns (the large squares in the corners) can be styled independently with cornerStyle:

<QRCode value="https://mantine.dev" cornerStyle="square" />   {/* Default */}
<QRCode value="https://mantine.dev" cornerStyle="rounded" />
<QRCode value="https://mantine.dev" cornerStyle="dots" />

Mix and match dot and corner styles for unique designs:

<QRCode
  value="https://mantine.dev"
  dotStyle="dots"
  cornerStyle="rounded"
  color="violet"
/>

Image Overlay with Excavation

Add a logo or image at the center of the QR code. The component automatically removes (”excavates”) the data modules behind the image to keep the code scannable:

<QRCode
  value="https://mantine.dev"
  size="xl"
  image="https://example.com/logo.png"
  imageSize={0.2}
  imageRadius="md"
  imagePadding={1}
  imageExcavate={true}
  errorCorrectionLevel="H"
/>

Tip: Use errorCorrectionLevel="H" when overlaying images — it provides 30% error correction, ensuring the code remains scannable even with a portion covered.

Error Correction Levels

Four standard error correction levels are supported via the errorCorrectionLevel prop:

useQRCodeDownload Hook

A dedicated hook makes it easy to export the QR code in multiple formats:

import { QRCode, useQRCodeDownload } from '@gfazioli/mantine-qr-code';

function Demo() {
  const { ref, download, getDataUrl } = useQRCodeDownload({
    fileName: 'my-qr-code',
    scale: 4,          // 4x resolution for raster formats
  });

  return (
    <>
      <QRCode ref={ref} value="https://mantine.dev" />
      <button onClick={() => download({ format: 'svg' })}>Download SVG</button>
      <button onClick={() => download({ format: 'png' })}>Download PNG</button>
    </>
  );
}

Supported formats: svg, png, jpeg, webp. The getDataUrl function returns a data URL — useful for preview thumbnails or embedding.

Theme-Aware Colors

Both foreground and background colors integrate with the Mantine theme:

<QRCode value="https://mantine.dev" color="blue" background="gray.1" />
<QRCode value="https://mantine.dev" color="white" background="dark" />
<QRCode value="https://mantine.dev" color="teal" background="transparent" />

Full Styles API

The component exposes 8 style selectors for granular customization:

CSS Variables

Size presets: xs (80px), sm (120px), md (160px), lg (200px), xl (256px).

🔧 Improvements

• SVG Accessibility: The SVG element includes role="img" and an aria-label derived from the encoded value.

• Optimized Rendering: All data modules are combined into a single <path> element, keeping the DOM minimal regardless of QR code density.

• Memoized Computation: QR matrix generation and SVG path building are wrapped in useMemo — re-computation only happens when relevant props change.

• SSR Compatible: No browser-only APIs (window, document) are used during rendering. The download hook uses browser APIs only when explicitly called.

📖 Complete Props Reference

interface QRCodeBaseProps {
  value: string;                              // Required — data to encode
  size?: MantineSize | string | number;       // Default: 'md'
  radius?: MantineRadius | string | number;   // Container border radius
  color?: MantineColor;                       // Default: 'dark'
  background?: MantineColor | 'transparent';  // Default: 'white'
  errorCorrectionLevel?: 'L' | 'M' | 'Q' | 'H'; // Default: 'M'
  quietZone?: number;                         // Default: 1
  dotStyle?: 'square' | 'rounded' | 'dots';  // Default: 'square'
  cornerStyle?: 'square' | 'rounded' | 'dots'; // Default: 'square'
  image?: string;                             // Center image URL
  imageSize?: number;                         // 0–1, default: 0.2
  imageRadius?: MantineRadius | string | number;
  imagePadding?: number;                      // Default: 1
  imageExcavate?: boolean;                    // Default: true
}

Getting Started

Install the package:

npm install @gfazioli/mantine-qr-code

Import styles at the root of your application:

import '@gfazioli/mantine-qr-code/styles.css';

Use the component:

import { QRCode } from '@gfazioli/mantine-qr-code';

function App() {
  return (
    <QRCode
      value="https://mantine.dev"
      size="lg"
      dotStyle="rounded"
      cornerStyle="rounded"
      color="blue"
    />
  );
}

Use Cases

{/* URL */}
<QRCode value="https://mantine.dev" />

{/* WiFi credentials */}
<QRCode value="WIFI:T:WPA;S:MyNetwork;P:MyPassword;;" />

{/* vCard contact */}
<QRCode value="BEGIN:VCARD\nVERSION:3.0\nFN:John Doe\nTEL:+1234567890\nEND:VCARD" />

Links

• 📦 npm package

• 📖 Documentation & Demos

• 🔗 GitHub Repository

• 🧩 More Mantine Extensions

Introduction

Mantine Scene is a brand-new composable background component for React that lets you build atmospheric, animated backgrounds by stacking visual layers. Think of it as a stage director for your UI — you compose the mood by combining gradients, glow effects, dot grids, star fields, snowfall, auroras, and more, all with first-class Mantine theme integration, responsive props, and accessibility baked in from day one.

This 1.0.0 release ships with 10 composable sub-components, full interactive mouse-tracking support, GPU-accelerated animations, and a complete documentation site with live configurators for every layer type.

What’s New in 1.0.0

The Scene Component

The root Scene component acts as a container for all visual layers. It supports fullscreen mode, interactive mouse tracking, and respects prefers-reduced-motion out of the box.

import { Scene } from '@gfazioli/mantine-scene';

function HeroBackground() {
  return (
    <Scene fullscreen interactive>
      <Scene.Gradient from="violet" to="transparent" animate />
      <Scene.Glow color="blue" size={300} />
      <Scene.StarField count={80} twinkle />
      <Scene.Noise opacity={0.03} />
    </Scene>
  );
}

Root Props:

10 Composable Sub-Components

Every sub-component is a visual layer you can freely compose. Layer order follows DOM order — the last child renders on top.

✨ Scene.Gradient

Radial, linear, or conic gradients with optional rotate or pulse animation. Supports interactive mouse tracking for radial/conic types.

<Scene.Gradient
  type="radial"
  from="violet"
  to="transparent"
  fromOpacity={0.2}
  animate
  animationType="rotate"
  duration={20}
/>

✨ Scene.Glow

Floating, animated glow blobs. Choose between float, pulse, or breathe animation styles. Supports responsive size and blur props and interactive mouse tracking.

<Scene.Glow
  color="cyan"
  size={{ base: 200, md: 400 }}
  blur={{ base: 80, md: 120 }}
  opacity={0.5}
  animate
  animationType="float"
  driftX="30px"
  driftY="20px"
/>

✨ Scene.DotGrid

Repeating dot patterns with optional stagger (honeycomb) layout, fade masks, and twinkle animation. Supports responsive spacing.

<Scene.DotGrid
  color="gray"
  spacing={{ base: 16, md: 24 }}
  stagger
  fade="radial"
  animate
/>

✨ Scene.Mesh

Multi-stop radial gradient overlay simulating a mesh gradient. Supports hue-rotate animation and blend modes.

<Scene.Mesh
  stops={[
    { color: 'violet', position: '20% 30%', spread: 50 },
    { color: 'pink', position: '80% 20%', spread: 40 },
    { color: 'blue', position: '50% 80%', spread: 60 },
  ]}
  animate
  blend="screen"
/>

✨ Scene.Noise

SVG-based film grain texture. Add subtle texture to any background with configurable grain, seed, and color tint.

<Scene.Noise opacity={0.03} grain={0.65} type="fractalNoise" tint="blue" />

✨ Scene.StarField

CSS-only star field with deterministic PRNG positioning and twinkle animation across 3 staggered layers. Supports responsive count.

<Scene.StarField count={{ base: 50, md: 100 }} twinkle duration={3} seed={42} />

✨ Scene.StarWarp

Hyperspace warp-speed effect with configurable focal point, direction, and streak trails. Supports responsive count and interactive mouse tracking for the focal point.

<Scene.StarWarp
  count={100}
  speed={1.5}
  direction="out"
  trail
  color="white"
/>

✨ Scene.ShootingStar

Animated shooting star trails at configurable angles and intervals. Multiple lanes with randomized timing for a natural feel.

<Scene.ShootingStar
  count={3}
  angle={215}
  trailLength={80}
  speed={1}
  minInterval={3}
  maxInterval={8}
/>

✨ Scene.Snow

Falling snowflakes with horizontal drift and wind control. Supports responsive count for performance-conscious responsive designs.

<Scene.Snow
  count={{ base: 30, md: 50 }}
  speed={1}
  drift={30}
  wind={0.2}
/>

✨ Scene.Aurora

Shimmering aurora borealis bands with wave animation. Configurable band count, position, and colors.

<Scene.Aurora
  colors={['green', 'teal', 'cyan']}
  bands={3}
  position="top"
  opacity={0.3}
  blur={60}
/>

Key Features

🎨 Full Mantine Theme Integration

Every color prop accepts MantineColor values, so your backgrounds stay consistent with your theme. Shade overrides are available on components like Glow and DotGrid.

📱 Responsive Props

Key numeric props support Mantine’s responsive object syntax. This means you can adjust visual density based on breakpoint — fewer stars on mobile, larger glows on desktop:

<Scene.StarField count={{ base: 40, sm: 60, md: 100 }} />
<Scene.Glow size={{ base: 150, md: 400 }} blur={{ base: 60, md: 120 }} />

Responsive props are available on: Glow (size, blur), DotGrid (spacing), StarField (count), StarWarp (count), Snow (count).

🖱️ Interactive Mouse Tracking

Set interactive on the root Scene to enable cursor-driven effects:

• Glow — blob position follows the mouse

• Gradient — radial/conic center follows the mouse

• StarWarp — focal point tracks the mouse

The interactiveEasing prop controls how smoothly elements follow the cursor (0 = sluggish, 1 = instant). Components gracefully fall back to their default positions when the mouse leaves.

♿ Accessibility

• The root component renders with aria-hidden="true" — it’s purely decorative

• reducedMotion="auto" respects prefers-reduced-motion by default

• Set reducedMotion="always" to disable all animations, or "never" to force them on

⚡ Performance

• All animations use GPU-accelerated CSS (transform, opacity) — no JavaScript animation loops

• Deterministic PRNG (seeded) for StarField, StarWarp, ShootingStar, and Snow ensures reproducible layouts without runtime randomness

• StarWarp caps at 200 elements; Snow recommends ~80 max for smooth performance

• Responsive count props let you reduce particle counts on lower-powered devices

🎛️ Styles API

Full Mantine Styles API support. Override styles for any part of any sub-component using classNames, styles, or unstyled props. CSS variables are exposed for all dynamic values (e.g., --scene-glow-size, --scene-aurora-duration).

Putting It All Together

Here’s a complete example combining multiple layers into a rich hero background:

import { Scene } from '@gfazioli/mantine-scene';

function CosmicHero() {
  return (
    <Scene fullscreen interactive interactiveEasing={0.08}>
      {/* Base gradient */}
      <Scene.Gradient type="radial" from="indigo" fromOpacity={0.2} animate />

      {/* Mesh overlay */}
      <Scene.Mesh
        stops={[
          { color: 'violet', position: '25% 25%' },
          { color: 'blue', position: '75% 75%' },
        ]}
        blend="screen"
        opacity={0.6}
      />

      {/* Floating glows */}
      <Scene.Glow color="cyan" size={350} top="20%" left="30%" />
      <Scene.Glow color="violet" size={250} top="60%" left="70%" delay={2} />

      {/* Stars */}
      <Scene.StarField count={{ base: 60, md: 120 }} twinkle />
      <Scene.ShootingStar count={2} />

      {/* Subtle texture */}
      <Scene.Noise opacity={0.02} />
    </Scene>
  );
}

Getting Started

Installation

npm install @gfazioli/mantine-scene
# or
yarn add @gfazioli/mantine-scene

Import Styles

Add the styles import to your app entry point:

import '@gfazioli/mantine-scene/styles.css';

Or use the @layer variant for CSS cascade control:

import '@gfazioli/mantine-scene/styles.layer.css';

Requirements

• React 18 or 19

• @mantine/core >= 7.0.0

• @mantine/hooks >= 7.0.0

Links

• 📦 npm package

• 📖 Documentation & Live Demos

• 🔗 GitHub Repository

• 🌐 Mantine Extensions Hub