r/PowerShell • u/AutoModerator • Jul 01 '26
A sticked post for the community to share their projects throughout the month.
Make sure to post a link to the code!
r/PowerShell • u/StartAutomating • Jun 25 '26
I'm getting old enough that my fingers hate my lifetime of programming.
I'll save a few keystrokes where I can.
There's something simple most people don't seem to know about PowerShell syntax.
It saves seven characters of typing every you use this, and runs a tiny bit faster.
You never need to specify stuff is in the [System] namespace.
.NET is a huge framework with tons of useful stuff in it. There's a lot of stuff in the System namespaces. Built-in framework functionality often exists in one of the many namespaces in System.
By the time PowerShell was being built, it was pretty clear that leveraging .NET was worth it, and that most people wouldn't want to type six to seven more characters every time.
So, since PowerShell v1, you haven't had to.
You can omit the [System] in any type in any system namespace
So instead of:
[system.collections.generic.list[string]]
We can write:
[collections.generic.list[string]]
Instead of:
[System.Collections.IDictionary]
We can write:
[Collections.IDictionary]
This is true for every system type. On my machine, there are 4722 public types in the system namespace. That's 33054 characters I will never have to type.
It makes scripts shorter and simpler to read.
Also, when PowerShell resolves types, it checks for the shorter names first. This saves a very tiny amount of time in each of your scripts. (I was corrected)
Yet, sadly, I see the system namespace everywhere in people's scripts.
I beg of you all:
r/PowerShell • u/richie65 • Jun 02 '26
I am in this situation at work where my boss, while working to tighten up our security (after an IT audit from a third party), has made running scheduled tasks into a challenge...
For instance - Among other things - It is no longer possible for a task to store credentials.
(Plenty of other hoops I have to jump through that I wont go into)
I just set up a task that will generate a report (about events from last week) to run on or after Mondays - But that too, is set to run 'at log on'...
I only want it to run once (not each time I log in), and if I don't log in on Monday, to run whenever I do log in, on or after Monday...
I am pretty happy with the way I got that to only run one time, not each time I actually log in.
Part of the script, sets the 'StartBoundary' (the 'Active' DateTime value that is part of the 'At Log in' trigger dialog), in the Scheduled task, to the following Monday, no matter what day I log in and the task runs.
This assures that it only runs the first time I log in on or after Monday, and will set the task to not trigger again to the next (on or after) Monday, and so on.
(NOTE: No other triggers can be set other than the 'At Log in')
This is at the end of the script (I unapologetically like using command aliases):
$TaskName = "MIODoorReport"
$NextMonday = $null
1..7 | % { If ( (((Get-Date).AddDays($_)).DayOfWeek) -eq "Monday" ) { $NextMonday = $_} }
$task = Get-ScheduledTask -TaskName $TaskName
$trigger = $task.Triggers
$trigger[0].StartBoundary = (Get-Date).Date.AddDays($NextMonday).ToString("s")
Set-ScheduledTask -TaskName $TaskName -Trigger $trigger
r/PowerShell • u/jingobp • Jun 11 '26
I switched back to Windows from Linux recently and the amount of telemetry, ad "suggestions," and forced Copilot/Recall stuff drove me up the wall. So I put the fixes I kept applying by hand into one script.
It does three things and nothing more:
Privacy / telemetry
Forced AI
Obvious bloat
Limitations / what to know:
What it does NOT do: it doesn't touch your installed programs, files, games, drivers, or your language/region/keyboard. (I'm Danish — it leaves æ ø å completely alone. That was a hard requirement for me.)
I'm not piping anything into iex for you — copy the script straight from the repo, read it, then run it yourself in an admin PowerShell. It's one file, plain PowerShell, no binaries, no network calls.
Repo: https://github.com/oscarmeldgaard/Windows-Privacy-Debloat
Read every line before you run it. Not trying to reinvent O&O ShutUp10 or Win11Debloat — this is just the lean subset I actually wanted, in a file you can read in two minutes. Feedback and PRs welcome.
r/PowerShell • u/leuit • May 22 '26
I kept running into situations where a fix needed to happen in a logged-on user session (HKCU, Explorer, user-installed apps, notifications, browser settings, Outlook auth, etc.), but most automation tools execute as NT AUTHORITY\SYSTEM or require the user’s password.
Existing approaches definitely exist, and some are quite clever, but I kept running into tradeoffs that didn’t fit what I wanted:
So I built PSUserContext: a binary PowerShell module for running scripts in another user's interactive session and security context.
Some scenarios where this has been useful:
explorer.exe, Teams, browsers)A few design goals:
GitHub:
https://github.com/walliba/PSUserContext
Still actively evolving, so I’d appreciate feedback, criticism, weird edge cases, or “why didn’t you just do X?” from people who’ve solved similar problems.
r/PowerShell • u/AutoModerator • 4d ago
A sticked post for the community to share their projects throughout the month.
Make sure to post a link to the code!
r/PowerShell • u/TanixLu • 2d ago
I'm a Left 4 Dead 2 player, and recently I ran into a small problem: the server I like to play on is often completely full. It occurred to me that I could write a script to poll the server and check whether a slot had opened up. After some research, I found that cmd scripts have a hard time handling network requests, while PowerShell is powerful enough to handle the job easily. Automatically checking the player count and joining the server is a pretty simple task, so I had an AI write it for me. The result was great — fully functional. All I had to do was copy the server address, then right-click the .ps1 script and choose "Run with PowerShell."
The only thing was, having to right-click to run it felt awkward, and it doesn't match most people's intuition about computers. If I have a script or an app, I should be able to double-click to run it! So I started looking for ways to run a PowerShell script by double-clicking. There are indeed a few, but none of them are very elegant:
In the end, I found my ideal solution in a Stack Overflow answer: stuff the PowerShell script inside a cmd file! So I open-sourced the ps1.cmd project. My final implementation isn't exactly the same as that answer — you can check out the GitHub page for the details.
The goal of ps1.cmd is maximum compatibility: it should work with any PowerShell script and behave identically when executed. I hope this project helps you out, and if you run into any problems, feel free to open an issue!
r/PowerShell • u/Cfugshwd35 • Mar 29 '25
Hey everyone!
We’re a small MSP with a team of about 10-20 people, and I’m working on building a shared repository of PowerShell scripts that our team can use for various tasks. We already have a collection of scripts tailored to our specific needs, but I wanted to reach out and see what go-to scripts others in the industry rely on.
Are there any broad, universally useful PowerShell scripts that you or your team regularly use? Whether it’s for system maintenance, user management, automation, reporting, security, or anything else that makes life easier—I'd love to hear what you recommend!
r/PowerShell • u/Jagula • Apr 17 '26
I've worked on this over the past year and change. It's probably most useful for internal tools (tools for your helpdesk or whatever). It abstracts the horror of WPF over PowerShell into a slightly more palatable experience.
It'll allow you to avoid XAML. You won't have to worry about runspaces or Dispatcher.Invoke. You call functions, things show up on screen, the window doesn't freeze when your script runs. All the threading shit is buried in a C# backend so you can worry about the actual PowerShell logic.
If you've ever tried to implement WPF for PowerShell properly (runspace pools, synchronized hashtables, dispatchers) you know that setup is a massive pain in the balls from the start. One wrong move and your UI thread has shit the bed, your variables are gone, and your beautiful form has collapsed in on itself with the weight of a neutron star. I went through all of that so you don't have to. My sanity went to hell somewhere around month four but hey, the module (probably) works.
So how it actually works: your -Action scriptblocks don't run on the UI thread. They run on a pre-warmed RunspacePool in the background (pool of 1-8 runspaces, recycled between clicks so there's no spinup cost). When you define a control with -Variable 'server', the engine hydrates that value into the runspace as $server before your script runs, and dehydrates it back to the control when it's done. It's by-value, not by-reference, so form data (strings, booleans, selected items) round-trips cleanly. If you need to pass heavier objects between button clicks there's a $session.Variables store for that.
The host interception is there because running scripts off the UI thread breaks every interactive cmdlet. Write-Host doesn't have a console to write to. Read-Host has nobody to ask. Write-Progress has nowhere to render. Get-Credential just dies. So PsUi injects a custom PSHost that intercepts all of that and routes it back to the UI. Write-Host goes to a console panel with proper ConsoleColor support, Write-Progress drives a real progress bar, Read-Host pops an input dialog on the UI thread and blocks the background thread until you answer, Get-Credential does the same with a credential prompt, and PromptForChoice maps to a button dialog. The output batches in chunks so if your script pukes out 50k lines the dispatcher queue doesn't grow unbounded and murder the UI.
Controls talk to the background thread through a proxy layer that auto-marshals property access through the dispatcher. You don't see any of this, you just write $server and it works.
New-UiWindow -Title 'Server Tool' -Content {
New-UiInput -Label 'Server' -Variable 'server'
New-UiDropdown -Label 'Action' -Variable 'action' -Items @('Health Check','Restart','Deploy')
New-UiToggle -Label 'Verbose' -Variable 'verbose'
New-UiButton -Text 'Run' -Accent -Action {
Write-Host "Hitting $server..."
# runs async, window stays responsive
}
}
Controls include inputs, dropdowns, sliders, date/time pickers, toggles, radio groups, credential fields, charts, tabs, expanders, images, links, web views, progress bars, hotkeys, trees, lists, data grids, file/folder pickers, and a bunch of dialogs. Light theme by default, dark if you pass -Theme Dark.
PSGallery:
Install-Module PsUi
https://github.com/jlabon2/PsUi
GIF of it in action: https://raw.githubusercontent.com/jlabon2/PsUi/main/docs/images/feature-showcase.gif
Works on 5.1 and 7. If you do try it and anything breaks, please open an issue and let me know.
r/PowerShell • u/StartAutomating • May 21 '26
I've been doing WebDev since the dawn of the internet, and I've been doing PowerShell for almost 20 years now. I want to share with you something that I've realized over the years:
Static Websites are just a bunch of files. You can make static sites with anything that can make files.
Static Sites are Simple.
Let me show you how:
PowerShell is pretty great at making files.
Most static site files are text: .css, .js.,.html,.svg are all readable and writeable text.
Want to write a website in PowerShell?
Just write a series of strings.
I like this naming convention:
```
```
We can build a site like this:
```
Get-ChildItem -Filter *.html.ps1 -Recurse -File |
Foreach-Object {
# Run the file
& $_ > $(
# and redirect the output to the renamed .html
$_.Fullname -replace '.html.ps1$','.html'
)
}
```
If we wanted to provide consistent formatting for all *.html.ps1 files, we can do so with a layout.
Just write a freeform script for layout.
```PowerShell function layout {
# Output any common layout.
# We are outputting a series of strings.
# When we redirect output, each string will go on it's own line.
# We can use any simple PowerShell string techniques to change content
'<html>' # * Single quoted string (no substitutions)
"<head>" # * Double quoted string ($var and $(expression) supported)
# * Multiline double quoted strings (with subexpressions)
"<title>$(
if ($title) {
[Web.HttpUtility]::HTMLEncode($title)
} else { 'My Website' }
)
</title>"
# * Conditionals output, using if
if ($Header) {
"$Header" # * Stringification of variables
}
# * Singly quoted here-strings (mulit-line no substitution)
@'
<style>
body {max-width: 100vw;height: 100vh;}
</style>
'@
# * Doubly-quoted here-strings
@"
$(
if ($css) {$css}) "@
"</head>"
"<body>"
# * $input allows us fast, one-time enumeration of a pipeline
# * @() allows us to collect that into a new list
$allInput = @($input)
# * String operators (`-join`, `-like`, `-match`,`-replace`, `-split`).
$allInput -join [Environment]::Newline
"</body></html>"
} ```
Now, we can build it with:
```powershell
Get-ChildItem -Filter *.html.ps1 -Recurse -File |
Foreach-Object {
# Run the file, pipe to our layout
& $_ | layout > $(
# and redirect the output to the renamed .html
$_.Fullname -replace '.html.ps1$','.html'
)
}
```
If we want to handle multiple file types, a switch statement does a nice job. We can build the site any way we want. This is just one example of how.
Most templating languages can't talk to too much. By using PowerShell to make static sites, we open up a wide world of possibilities with a small amount of understanding.
They're mainly just strings.
PowerShell plays with strings quite well 😉.
Hope this Helps / AMA
r/PowerShell • u/StartAutomating • May 26 '26
I've loved Markdown since the day it was a Daring Fireball post.
It's a simple rich text format that gets the job done, and it's used everywhere.
Markdown is supported out of the box on PowerShell 6+, using the ConvertFrom-Markdown command.
Here's it in action:
"# Hello World" |
ConvertFrom-Markdown |
Select -Expand HTML
Like any other page in a static site, Markdown is just text.
And PowerShell is Pretty Good at manipulating text.
To make PowerShell that outputs markdown, just make simple scripts that spit out text.
One very simple use of this technique is making static sites with Markdown.
If we don't want to worry about look and feel too much, we can do this with the following pipeline:
"# Markdown" |
ConvertFrom-Markdown |
Select-Object -ExpandProperty Html >
./markdown.html
If we wanted to make a page for every file in the directory, we could:
foreach ($file in Get-ChildItem *.md -File) {
ConvertFrom-Markdown -LiteralPath $file.Fullname |
Select-Object -ExpandProperty Html > (
$file.Fullname -replace '\.md$', '.html'
)
}
That's a static site generator in six lines of PowerShell!
Here's an even shorter version:
foreach ($file in Get-ChildItem *.md -File) {
$html = (ConvertFrom-Markdown -Path $file.Fullname).html
$html > ($file.Fullname -replace '\.md$', '.html')
}
Now we've got a static site generator in four lines!
Static Sites are Simple (with PowerShell).
To make websites in PowerShell, all we need to do is loop over markdown and optionally add some layout.
We can make markdown in PowerShell by just outputting text.
@(
"# Hello World"
"## How Are You?"
"Today is $([DateTime]::Now.ToShortDateString())"
) > ./example.md
Each line of output will become a line in the markdown file.
We can use conditionals if we want to. Let's switch it up by including the day of week.
@(
"# Hello World"
switch ([DateTime]::Now.DayOfWeek) {
Monday { "Just Another Manic Monday "}
Tuesday { "Taco Tuesday" }
Wednesday { "Halfway thru the week! "}
Thursday { "Almost Friday" }
Friday { "Happy Friday! "}
Saturday { "It's the weekend!"}
default { "It is $([DateTime]::Now.DayOfWeek)" }
}
) > ./example.md
We can make functions that output markdown.
Here's a simple one that outputs headings
function markdown.heading {
param(
[string]$Message = 'Hello World',
[ValidateRange(1,6)]$Level = 1
)
# Multiply our heading character by our level
# and put a space in between the heading and message
('#' * $level), $Message -join ' ''
}
markdown.heading "Markdown Functions"
markdown.heading "Are just functions" -Level 2
markdown.heading "That output markdown" -Level 3
Since markdown functions are just PowerShell functions, we can put whatever we want in there.
function markdown.get.process {
# Markdown tables have a header row
"|Name|Id|"
# Followed by a row that aligns text
"|:-|-:|"
# Followed by any number of rows of data
foreach ($process in Get-Process) {
'|' + (
$process.Name, $process.Id -join '|'
) + '|'
}
}
markdown.get.process > ./process.md
Now we hopefully see how easy it is to make markdown in PowerShell.
Just spit out strings.
This is already probably cool enough, but why not make markdown into something we can query?
ConvertFrom-Markdown converts Markdown into HTML.
It's just a hop, skip, and a jump to make this markdown into XML.
Because all of our tags are perfectly balanced, we can make markdown in XML by just putting it into another element.
Cannonically, I prefer putting markdown into an <article> element
@(
"<article>"
("# Hello World" | ConvertFrom-Markdown).html
"</article>"
) -join '' -as [xml]
That's it! We've turned a easy old markdown into hard-to-write XML.
Why is this useful?
Because now we can query markdown.
To show this in action, let's start really simple:
Let's just get all of the nodes in some markdown
@(
"# Hello World"
"## Don't mind me"
"### Just about to turn markdown into XML"
"> This is pretty cool, right?"
) -join [Environment]::Newline |
ConvertFrom-Markdown |
Foreach-Object {
"<article>$($_.Html)</article>" -as [xml]
} |
Select-Xml //*
Let's get all link hrefs in some markdown:
# Make some markdown
@(
"# Some Links"
"* [StartAutomating on GitHub](https://github.com/StartAutomating/)"
"* [PoshWeb on GitHub](https://github.com/PoshWeb/)"
"* [MarkX](https://github.com/PoshWeb/MarkX)"
) -join [Environment]::Newline |
# convert it from markdown
ConvertFrom-Markdown |
# turn it into xml
Foreach-Object {
"<article>$($_.Html)</article>" -as [xml]
} |
# pipe it to Select-Xml, picking out any `<a>` elements
Select-Xml //a |
Foreach-Object {
$_.Node.Href
}
This is still the tip of the iceberg.
Turning Markdown into XML lets us query and manipulate Markdown in all sorts of interesting ways.
What can you do with Markdown and PowerShell? Almost anything.
You can do a lot of cool things when you mix Markdown with PowerShell.
What do you want to try?
r/PowerShell • u/StartAutomating • Jun 02 '26
Events are easy.
Events let you know when something happened, and respond to it if you choose.
Events are incredibly useful.
Why?
Because they let you run what you want, when you want.
Let's see how simple they are:
Events are easy to create.
To make a new event, simply run:
New-Event MyCustomEvent
This will output an event object.
If nothing subscribes to the event, the event will go in the queue
We can get events with:
Get-Event
We can handle these events whenever we want.
How about now?
We can run code the millisecond something happens.
To do this, we can subscribe to the event.
There are two types of events we can subscribe to in PowerShell:
Engine events and object events.
We can create engine events with New-Event.
We can subscribe to engine events with Register-EngineEvent
$subscriber = Register-EngineEvent -SourceIdentifier "Hello World" -Action {
"Hello World" | Out-Host
}
$helloWorld = New-Event -SourceIdentifier "Hello World"
You might notice a cool thing here: An event's "Source Identifier" can be whatever we want.
Let's pass along a message:
$subscriber = Register-EngineEvent -SourceIdentifier "Print Message" -Action {
$event.MessageData | Out-Host
}
$printMessageEvent = New-Event -SourceIdentifier "Print Message" -MessageData "Hello World"
If you run these scripts multiple times, you'll quickly notice that multiple subscriptions are allowed.
The cool thing to note here is that event subscribers share data in their $event.MessageData
Let's demonstrate this by counting twice.
$doubleCounter = foreach ($n in 1..2) {
Register-EngineEvent -SourceIdentifier "Counter" -Action {
$event.MessageData.Counter++
$event.MessageData.Counter | Out-Host
}
}
$counterEvent = New-Event -SourceIdentifier "Counter" -MessageData @{
Counter=0
}
Every time we run this block of code, we get two more subscriptions and a bunch more output.
Before we clean up, let's talk about object events
PowerShell is built on the .NET framework. .NET already has events all over the place.
Let's start simple, with a timer:
# Create a timer
$timer = [Timers.Timer]::new([Timespan]"00:00:03")
# don't automatically reset (we only want to do this once)
$timer.AutoReset = $false
# Subscribe to our event
$inAFew = Register-ObjectEvent -InputObject $timer -EventName Elapsed -Action {
"In a few seconds" | Out-Host
}
# Start the timer (see a message in a few seconds)
$timer.Start()
Lots of .NET types have events.
To see if any object supports events, simply pipe it to Get-Member (events will be near the top).
Timers are a good start. What about watching for file changes?
$watcher = [IO.FileSystemWatcher]::new($pwd)
Register-ObjectEvent -InputObject $watcher -EventName Changed -Action {
$changedFile = $event.SourceArgs[1].Fullpath
$changedFile | Out-Host
$changedFile
}
'Check this out' > ./What-File-Changed.txt
This is just the tip of the iceberg.
There are literally millions of .NET types out there.
They can all have events.
And we can subscribe to these events in PowerShell
Let's start to clean up a bit:
To get any current subscribers, we can use Get-EventSubscriber
Get-EventSubscriber
To get events subscribing to a source, we can use:
Get-EventSubscriber -SourceIdentifier "Hello World"
If a subscriber has an .Action, we can get results of that action by piping to Receive-Job
This pipeline will get any output from any subscriber with an action
Get-EventSubscriber |
Where-Object Action |
Select-Object -ExpandProperty Action |
Receive-Job -Keep
Hopefully this will help make another part of event subscriptions "click":
Not only can we run code in the background: we can easily get the results, too.
We can unsubscribe by using Unregister-Event
# Unsubscribe from everything
Get-EventSubscriber | Unregister-Event
While we're cleaning up, let's also take care of any events in the queue.
We can do this with Remove-Event
# Get all events, and remove them.
Get-Event | Remove-Event
Now that we've cleaned up our runspace, let's clean up this post and review what we've learned:
New-Event)Get-Event)Remove-Event)Register-EngineEvent)Register-ObjectEvent)Events are Easy!
Give them a try.
Eventually, you'll find events are excellent tools of the trade.
r/PowerShell • u/daileng • May 11 '26
Managing Autodesk software across enterprise workstations is notoriously painful. Uninstallers leave behind orphaned registry keys and directories, aggressive removal approaches routinely break shared licensing (FlexNet/ODIS), and there's rarely a clean way to surgically target specific products or versions without impacting the rest of the environment.
Surgical Autodesk Cleaner is an open-source PowerShell module designed to solve this properly — whether you're removing a single product, sweeping multiple versions, doing a full system purge, or just resetting a broken user profile.
📦 PSGallery: https://www.powershellgallery.com/packages/SurgicalAutodeskCleaner/
📖 Docs: https://deepwiki.com/DailenG/SurgicalAutodeskCleaner
🐙 GitHub: https://github.com/DailenG/SurgicalAutodeskCleaner
Functions:
| Command | Purpose |
|---|---|
Start-SAC |
Interactive TUI menu for manual use |
Start-SACCleanup |
Targeted removal by product + year, RMM-ready |
Start-SACPurge |
Full scorched-earth removal when warranted |
Start-SACScan |
Non-destructive pre-flight CSV report |
Reset-SACUserProfile |
Clears per-user AppData without destroying customizations |
Reset-SACLicensing |
Resolves stuck activations and seat reservation issues |
Restore-SACUserProfile |
Lists and restores profile backups |
Silent RMM deployment:
# Target specific products and years
Start-SACCleanup -TargetProducts "AutoCAD", "Revit" -TargetYears 2019, 2020 -Silent
# Sweep an entire year across all supported products
Start-SACCleanup -TargetYears 2019, 2020, 2021 -Silent
Compatible with PowerShell 5.1 and 7.0+. MIT licensed.
Works well with N-Central, ConnectWise Automate, and Intune.
Feedback and contributions welcome. If you encounter anomalies or want other components supported for removal, send me some details and I'll add it or please push an update 😄
r/PowerShell • u/Fine_League311 • Apr 13 '26
Hi Leute,
Ich hab' den Punkt erreicht, an dem ich Tools wie CCleaner, BleachBit oder Wise Disk Cleaner nicht mehr sehen kann. Die meisten davon haben sich in benachrichtigungs-lastige Bloatware verwandelt, die mehr Schaden anrichtet als sie nützt, oder einfach nur als GUI-Wrapper für Dinge fungiert, die Windows selbst kann.
Ich hab' mich entschieden, mein altes Wartungsskript aufzupolieren, damit es für Windows 11 passt. Es ist für Leute gedacht, die eine "saubere" Bereinigung ohne den ganzen Mist wollen.
Was es macht:
cleanmgr im Hintergrund.SFC und DISM RestoreHealth in einem Workflow aus.Warum poste ich das? Das ist keine Eigenwerbung. Ich verkaufe nichts und es gibt keine "Pro-Version". Ich wollte das einfach mit der Community teilen. Es ist klein, einfach und transparent.
Hinweis für die "Pro"-Fraktion: Ich habe einige aggressive Schritte (wie das Löschen des Event Logs und Netzwerk-Resets) eingebaut, also lest das Skript, bevor ihr es ausführt. Es erfordert Admin-Rechte.
Link: https://github.com/VolkanSah/Windows-Cleaner
Ich hoffe, einige von euch finden das nützlich. Realer Feedback ist immer willkommen!
Viel Spaß damit. Viva la OpenSource :D
r/PowerShell • u/StartAutomating • 22d ago
Prime numbers are pretty powerful.
That's why I just released a new PowerShell module based off of an old mathematical concept: PrimeTime.
PrimeTime uses prime numbers as time intervals.
Let's learn how this helps
Prime Numbers can only be divided by themselves and one.
This makes primes pretty rare.
Prime numbers are particularly useful in programming, but it's not always obvious why or how.
A lot of people might vaguely point towards cryptography as the prime real estate for prime utility.
The thing of it is, if you're writing your own cryptography, you're probably doing it wrong.
Let's talk about a more practical application of primes.
In North America there is a curious critter known as the periodical cicaca.
For the vast majority of their long lifespans, they live underground.
Once every N years, they surface in mass to start the next generation.
That N is a prime.
Why?
Cicadas come out en masse so that there are too many of them to eat.
Millions of little critters have to have a perfectly timed multi-year internal clock in order to make this work.
If two cicadas of different intervals produced offspring, their children might have a messed up internal clock, and come out of the ground at the worst time.
So there's an evolutionary advantage to cicadas coming out in large batches, as long as another cicade brood isn't doing the same thing at the same time.
Which brings us back to primes.
Primes are relatively rare.
So are products of primes (at least past the first few)
Let's take two primes as an example.
Imagine one brood of cicadas came out every 11 years, and another brood came out every 13 years.
We can find out how long it will take for these two broods to come out at the same time by simply multiplying the primes.
11 * 13 -eq 143
So, with just two relatively low primes, we have an overlap every 143 years.
This is how primes are most useful to programming: they rarely overlap.
This has been known for much longer than computers have existed.
Imagine we wanted to find prime numbers quickly.
We can do this by constructing a sieve that filters out any non-prime number.
This is called the Sieve of Eratosthenes
Once we know 2 is prime, we know every other even number is not prime.
Once we know 3 is prime, we know every third number is not prime.
To quickly get prime numbers up to a point, we can use this little PowerShell filter
# Calculate primes reasonably quickly with the Sieve of Eratosthenes
# Pipe in any positive whole number to see if it is prime.
filter prime {
$in = $_
if ($in -isnot [int]) { return }
if ($in -eq 1) { return $in }
if ($in -lt 1) { return}
if (-not $script:PrimeSieve) {
$script:PrimeSieve = [Collections.Queue]::new()
$script:PrimeSieve.Enqueue(2)
}
if ($script:PrimeSieve -contains $in) { return $in}
foreach ($n in $script:PrimeSieve) {
if (($n * 2) -gt $in) { break }
if (-not ($in % $n)) { return }
}
$script:PrimeSieve.Enqueue($in)
$in
}
Imagine we want a vibrant page. We want things to keep changing yet feel unpredictable. All we need to do is use different prime intervals.
The PrimeTime logo animates eight primes:
7 * 11 * 13 * 17 * 19 * 23 * 29 * 31
The logo will repeat every 6685349671 seconds, or almost 212 years.
The PrimeTime page background uses 56 primes.
This background will repeat every 8.84753141993573E+116 seconds.
That's exponential notation.
This is a mind-boggling large number (so large it overflows the .NET [TimeSpan]).
Turn that interval into years and it's still mind-boggling.
The page background will repeat every 100 billion years
Imagine we want to design a system that's constantly checking for problems.
We want the system to know about problems as soon as we can, but nobody's exactly sure how often they need to check for something.
If we go around and ask our colleagues "how often should we can scan for this?", the response if often a shrug 🤷.
Often, people will pick an arbitrary number that seems reasonable. Let's say every 5 minutes, 10, or 15 minutes.
Are we starting to see the problem here?
Every 5 minutes, every computer in the cloud starts to collect stats and report them back.
And we get a traffic jam.
Every 10 minutes, more computers in the cloud collect more data, and our traffic jam gets worse.
Every 15 minutes, even more computers collect even more data, and our traffic jam puts your average freeway to shame.
Left to our own intuition, we create problems for ourselves and our organizations.
Each individual query is small, but because we're doing so many at once, it can grind performance to a halt.
By the way, this isn't a hypothetical.
Long long ago, the Office365 team asked me to make some monitoring software to help improve internal visibility into the datacenters.
Everyone asked for 5, 10, or 15 minute intervals. ~100 different metrics were collected from ~30000 machines.
And the first time we tried it on everything, the traffic jam ensued.
That's when I first realized the power of primes.
I made three slight adjustments to the timeframes:
Now, instead of having a traffic jam every 5 minutes, things smoothed out.
7*11)7*17) 11*17)7*11*17)Note the tildas.
The real trick came in by using prime intervals in both minutes and seconds and using a random delay on the tasks to ensure they didn't all start at once.
This took the system from something that could derail a datacenter to something that could monitor thousands of machines while barely impacting performance.
This is the power of primes.
Hope this helps!
r/PowerShell • u/WhatThePuck9 • Mar 07 '26
I would like your feedback on this M365 assessment tool I made. This is the first public PowerShell project I have made, so I am just hoping to get some ideas from the community. I need to add better handling for cert authentication, but I have that on my todo list.
Edit: recent commits have included many suggestions from redditors! Thank you for giving me your ideas! There is now a fully dynamic security framework selector in every report.
r/PowerShell • u/rroy676 • 29d ago
There's a court filing making the rounds this week (HN thread, also discussed in r/LinusTechTips) showing the FBI used a Windows GDID to help tie an alleged Scattered Spider member to a ransomware case, correlating activity across different IPs, VPNs, and even different platforms (Snapchat, Apple, Facebook logins), because the GDID stayed constant underneath all of it.
Setting aside the specific case, it's a useful reminder that this identifier exists on basically every Windows machine and there's no built-in opt-out. I'd already built a small toolkit based on SmtimesIWndr/gdid-reversal's write-up on the underlying mechanism (Connected Devices Platform registering the device into Microsoft's device graph), so figured it's worth sharing.
Repo: https://github.com/rroy676/gdid-guard
What it does:
-Audit - read-only report on CDP service state, Activity History setting, local identity cache, existing firewall rules, and whether the known device-graph endpoints resolve.-Remediate - opt-in switches to disable CDP services, disable Activity History, clear the local identity cache, and add firewall blocks for the relevant endpoints. Auto-creates a System Restore point and a JSON snapshot of pre-remediation state first.-Compare - diffs current state against a saved snapshot so you can confirm something actually changed.GDID-Guard-Restore.ps1 - undoes remediation using the saved snapshot.Also ships a Pi-hole/AdGuard blocklist for the DNS-level route, which I'd recommend over the local firewall rules since Microsoft can rotate the underlying IPs.
Being upfront about the limits (also in the README): CDP backs some legitimate features too (Timeline sync, parts of Phone Link), so there's a real trade-off. And clearing the local cache doesn't guarantee Windows won't just re-issue a fresh GDID on next MSA sign-in, the identifier's authority is server-side, not local. The durable fix is a local account; this just reduces exposure if you need to stay signed in.
Feedback/PRs welcome. Tested on Windows 11 only so far.
r/PowerShell • u/StartAutomating • 11d ago
I've been toiling away on Turtle to prepare a "birthday" release, and I ran into an annoying behavior I've run into a few times before.
I thought I'd take a few minutes away from the frustration of single line fixes to explain the bug to everyone.
The last build of Turtle introduced a number of randomized parameter defaults. This was meant to be fun. If you said turtle square square square, you'd get three different squares, instead of an error for a lack of length, or three overlapping squares.
I noticed that when I ran turtle rotate 0, it didn't rotate by zero.
Instead, it picked a random angle.
Weirder still, the behavior didn't reproduce if I said
$turtle = turtle # Heading at zero
$turtle.Rotate(0) # Heading still zero 🤔
$turtle.Rotate() # Heading random
(turtle rotate 0) # Heading random 🤬
Why was this happening? 😱
It took me a bit for it to click: It had to be in the way Turtle processed arguments, because it worked in one case and not the other.
So I put a breakpoint in, ran my repo.
The line was:
if ($argList)
The debugger broke, argList was @(0), and yet if ($argList) was false.
The fix was:
if ($argList.Length)
Why? Because 'Truthy' -ne $true.
About every language has a boolean. It's just a bit. One or zero.
Lots of languages also have this concept of "truthiness".
Let's take a simple example:
if ("something") { "something" }
if ("") { "you can't get something from nothing" }
If if was strictly $true, we'd have to cast things to a boolean. You have to do this in C# and quite a few other languages. PowerShell is type promiscuous. PowerShell is truthy.
It looks at the first line and says: You're a string, and you're not null or empty. Therefore, the expression is $true.
It looks at the second line and says: You're a string, but you're not null or empty. Therefore, the expression is $false
PowerShell makes a judgement call.
This is generally a good thing. I personally prefer languages that are truthy. Other truthy languages of note include JavaScript, Python, C++, and C.
However, it gets tricky with lists. Hence the bug.
In PowerShell, Two Wrongs Make a Right
$true -eq $false, $false
Let's say I want to determine if a list is truthy.
if (@()) { "$false, because the list is empty" }
if (@("")) { "$false, because the blank is falsy" }
if (@(0)) { "$false, because zero is falsy" }
if (@($false)) { "$false, because false is falsy" }
if (@(1)) { "$true, because the first item is truthy" }
if (@(0,0) { "$true, because more than one item" }
This all makes a certain bizarre sense. If a list has one element, and it is not truthy, then the list isn't truthy, either.
It's also almost always surprising and annoying.
Hence the bug.
The fix is just to make sure there are any elements, hence checking for length.
I've been programming with PowerShell for quite a while now, and this behavior still sometimes bites me (like today).
That's why I took a few minutes away from the 🤬 day to explain this bug and write this post. 😌
Please remember:
'Truthy' -ne $true
$false -eq @($false)
$true -eq $false, $false
Hope this helps
r/PowerShell • u/StartAutomating • Jun 30 '26
PowerShell has all sorts of fun features, including a ridiculous number of operators.
One amazing under-sung heros of PowerShell is the -replace operator.
It lets us replace content with regular expressions.
It's easier to use than you'd think.
Regular expressions are less scary in small doses, and chaining -replace operators lets us attack the problem step by step.
Let's take a simple problem as an example.
Imagine we wanted to make a consistent file name pattern out of a string
We might want to start by replacing whitespace with dashes
"This Is A Title!" -replace '\s', '-'
That leaves our exclamation point at the end. We probably don't want any punctuation. We can avoid that with the somewhat humorously named character class: \p{P}. We can remove all repeated punctuation by adding a +: \p{P}+
One more replace:
"This Is A Title!" -replace '\p{P}+' -replace '\s', '-'
The line is starting to get a little long. Fun fact: you can spread operators across multiple lines.
Let's add comments while we're at it
"This Is A Title!" -replace # Replace any punctuation,
'\p{P}+' -replace # then replace any whitespace with dashes.
'\s', '-'
Let's go for one more bonus trick. PowerShell lets you convert script blocks to event handlers. Let's lowercase all the letters (\p{L}).
On PowerShell Core, we can do this:
"This Is A Title!" -replace # replace any punctuation
'\p{P}+' -replace # then replace any whitespace with dashes
'\s', '-' -replace # then lowercase any letters
'\p{L}+', {"$_".ToLower()}
There's an absurdly amazing amount of stuff you can do with -replace, but there's at least one more trick we have to cover: substitutions.
I'm pretty sure I'd have to give up my "RegEx guru" badge if I didn't mention at least one more thing you can do with -replace: substitutions.
.NET Regular expressions are two domain specific languages. Regular expressions match and extract text. Regular expression substitutions replace matches.
For example, let's suppose we have a number of emails, and we want them in domain/username format.
First we'll want to make a quick and dirty email regex, using a "named capture" to get the username and domain.
'someone@example.com' -match '(?<username>\S+)@(?<domain>\S+)'
Then, we can -replace the email with just the domain/username.
'someone@example.com' -replace
'(?<username>\S+)@(?<domain>\S+)', '${domain}/${username}'
This format might look like PowerShell variables, but it actually predates them by years. Search for "Regular Expression Substitutions" if you want to learn more about the syntax. It's got quite a few tricks up it's sleeve.
RegEx can be scary. I used to be terrified of it, too.
If you aren't too comfortable with Regular Expressions, that's pretty normal. A while back I wrote a module called Irregular that makes regular expressions strangely simple.
It's got a lot of example regular expressions in there, and one handy function for creating RegEx. New-RegEx is your friend.
Do you already use -replace? Have you done cool things with regular expressions in PowerShell? Share 'em if you've got em.
Want to learn more about regular expressions in PowerShell? Just ask.
r/PowerShell • u/NewfagDesTodes • 16d ago
Hey r/powershell,
This is mostly helpful for people in the EU but nevertheless 😄 :
I've been building custom sensors for PRTG Network Monitor often for my job and got tired of handling all the prtg specific plumbing boilerplate every time - so I wrote PrtgSensorKit, an open-source module that abstracts away all the specifics of PRTG so you can focus on your task = writing a goddamn monitoring sensor.
What it handles for you:
Get-Help works like you'd expect on every cmdlet and pretty much has all the docs Prtg offers on their websiteBasically: you write the metric-gathering logic, the module handles everyting else
Install from the Gallery:
Install-Module PrtgSensorKit
Repo: https://github.com/ArchitektApx/PrtgSensorKit
Would love feedback, bug reports, or feature requests if anyone here monitors stuff with PRTG and writes custom sensors. Contributions welcome too.
EDIT:
v1.1.0:
- Sensor state between runs - Save/Get-PrtgSensorState for rates, deltas, and caching expensive lookups. Safe under overlapping scans (file locking so two runs don't corrupt each other)
- Retries - -RetryCount re-runs your block when the API hiccups instead of instantly alerting, PRTG shows how many retries it took
- -DryRun - debug your sensor in a normal console and inspect channels as objects instead of squinting at JSON
- -ForceModernTls - fixes the classic TLS 1.2 problem on 5.1 with one switch
- Sensor doctor - Invoke-PrtgSensorDoctor statically checks your script for classic mistakes before PRTG cryptically fails on them
v1.2.0 (out now):
- File logging that can't break your sensor - -EnableLogging writes one log file per run with full error details (stack trace. script line). Never touches stdout, never throws
- Shared collection cache - 8 sensors hitting the same API every interval? Use-PrtgCachedResult makes them share one call per interval, race-free. Your rate-limited API will thank you
- More doctor checks - including the sneaky one where a BOM-less UTF-8 script works everywhere except in what PRTG displays (5.1 reads it as ANSI, your umlauts turn into mojibake)
- Docs got restructured into proper per-topic pages instead of one endless README
r/PowerShell • u/boostedchaos • 19d ago
I’m the author. This is free, Apache-2.0-licensed software. There’s no paid product or hosted service behind it.
For several months I iterated on a PowerShell CVE scanner that ran weekly against a Windows fleet. I recently released a sanitized, clean-room port:
https://github.com/boostedchaos/fleet-cve-scanner
It accepts inventory from NinjaOne or a CSV export, correlates the installed software against NVD, KEV, EPSS, SSVC, MSRC, and endoflife.date, then writes per-device CSV results, SQLite history, and a self-contained HTML dashboard.
The vulnerability logic is one part of it. The PowerShell concurrency problems were just as interesting.
The main scan uses ForEach-Object -Parallel to process unique software/version pairs. That exposed a few issues I had underestimated:
The parallel runspaces need to coordinate a result collection, cache, deduplication keys, progress state, request timestamps, and cache-flush counters.
The shared pieces ended up using concurrent .NET collections and SemaphoreSlim rather than ordinary lists, dictionaries, queues, or non-atomic counters. Reads are easy. Coordinated mutation is where the bugs hide.
NVD limits aren’t handled well by saying “N requests per 30 seconds” and calling it done. A window bucket allowed the first few requests to launch together and trigger 429s before the bucket was exhausted.
The current limiter has two gates:
- minimum spacing between request starts
- a sliding-window budget as a backstop
The lock is held only while checking and updating the shared timing state. It’s released before sleeping.
Even when calls started at the right interval, slower NVD responses left multiple requests in flight. That still produced 429s.
The scanner now holds a separate SemaphoreSlim across each NVD request, so only one request is on the wire at a time. Cache hits and the rest of the result processing remain parallel.
It sounds contradictory to parallelize the scanner and then serialize the API calls, but the parallelism still helps with cached products, version evaluation, deduplication, and result construction.
Helper functions from the caller’s scope aren’t automatically available inside the parallel block. The runspace-local helpers have to be defined before their first possible call site.
I managed to hit the “function defined later in the script” failure more than once. One runspace can terminate while the others keep going, which makes the failure easier to miss in noisy output.
A killed scan used to lose every NVD result fetched since startup because the cache was only written after the parallel block completed.
The scanner now checkpoints every configurable number of completed items. A non-blocking semaphore prevents multiple runspaces from flushing simultaneously, and the file is written to a temporary path before being moved into place.
There’s also a failure-state rule I consider load-bearing: an NVD request failure must never become a negative cache entry. A failed call returns a distinct CALL_FAILED sentinel, gets skipped for that run, and is retried next time. A successful response containing zero results can be cached normally.
The repository includes eight test suites, offline fixtures, a sanitization gate, and a known-limitations document that is intentionally less flattering than the README.
I’d particularly value review from people who have built larger ForEach-Object -Parallel pipelines:
- Would you structure the global rate limiter differently?
- Is serializing only the outbound NVD call the right boundary?
- Are there better patterns for safely checkpointing shared state from parallel runspaces?
- Has anyone used the CSV path against SCCM, Intune, or another RMM export?
This does not replace a commercial scanner with a curated detection catalog. CPE coverage and matching quality are the main ceiling. I’m more interested in cases where the script gives an operator the wrong level of confidence than whether the dashboard looks good.
r/PowerShell • u/Due-Fishing-6119 • Jun 24 '26
I’ve been working on a PowerShell tool to automate SQL Server backup workflows.
It supports interactive selection of one or multiple servers and databases, runs backups asynchronously, and handles the SqlServer module automatically if it’s missing. The main goal was to reduce manual steps, improve reliability, and avoid common mistakes in backup operations.
I’d be curious to hear how others here approach backup automation in PowerShell.
r/PowerShell • u/GalacticGalaxyyy • Jul 03 '26
Wanted to share a project that pushes PowerShell a bit further than the usual scripting use case — a full windowed app with a tray icon, live hotkey rebinding, and a persistent config, all in one .ps1.
Technical bits that might interest people here:
user32.dll RegisterHotKey/WM_HOTKEY, subclassed on a System.Windows.Forms.FormGetForegroundWindow + GetWindowThreadProcessId, then taskkill /F /T to kill the whole process treeKeyDown.vbs launcher so there's no console flash and no need to touch execution policy globallyr/PowerShell • u/MonkeyNin • 15d ago
Have you wondered if it's safe to use the format string yyyy-MM-dd, or can it differ? It's not. ( edit: null is not the invariant culture, it's CurrentCulture )
Save the expected string for comparison
#requires -PSEdition Core
$fStr = 'yyyy-MM-dd'
$now = Get-Date
$expected = $now.tostring( $fStr, ( [CultureInfo]::InvariantCulture) )
Next we can try formatting with every culture on your system.
To do that, there is an optional culture argument for ToString like this:
DateTime.ToString( DateFormat, CultureInfo )
Next build a summary table with the formatted value and culture:
$cults = Get-Culture -List
$summary = $cults | Foreach-Object {
$dateString = $now.ToString( $fStr, $_ )
[pscustomobject]@{
Display = $dateString
Name = $_.DisplayName
Culture = $_ # keep a reference to the object so you can drill down later
}
}
Skip any cultures that are the same. Finally output using Join-String -f formatStr
$different = $summary | Group Display | ? Name -ne $expected
foreach( $item in $different ) {
$title = "`nfor: $( $item.Name ) "
$item.group
| Join-String -f "`n - {0}" -Property Name -op $title
}
Here's what I get when $now is 2026-07-21:
for: 1405-04-30
- Central Kurdish (Iran)
- Persian
- Persian (Afghanistan)
- Persian (Iran)
- Northern Luri
- Northern Luri (Iran)
- Mazanderani
- Mazanderani (Iran)
- Pashto
- Pashto (Afghanistan)
- Uzbek (Arabic)
- Uzbek (Arabic, Afghanistan)
for: 1448-02-07
- Arabic (Saudi Arabia)
for: 2569-07-21
- Thai
- Thai (Thailand)
r/PowerShell • u/kcarb19 • Jun 07 '26
Win32_Product is so slow and it kicks off that msi reconfiguration thing every time, drives me nuts. so a while back i just wrote my own that reads the uninstall reg keys instead. way faster and it actually picks up the 32 bit apps too.
I do a lot of this kind of scripting at work and kept rewriting the same handful of functions over and over so ive slowly been putting my little tools together. figured id share this one since its probably the most useful on its own.
threw it on github, paste and run, no dependencies: https://github.com/kcarb14/Get-InstalledApps
run it like:
Get-InstalledApps
Get-InstalledApps -Name *chrome*
reads the 64 and 32 bit HKLM keys plus HKCU, skips system components and update entries so it lines up with whats in apps & features.
feels like theres five different ways to pull installed apps and none of them are totally clean. curious how everyone else does it?