2026

Behind the Scenes of PwshSpectreConsole - Andree Renneus - PSConfEU 2026

PowerShell Conference EU
June 1-4, 2026
Dorint Pallas Wiesbaden
https://github.com/psconfeu/2026 (slides, code)

In this talk, Andree gives an overview of the internals of the PowerShell Spectre Console module and explains that it wraps the ....NET Spectre.Console library to make it easier to use from PowerShell. He describes the main goal as improving PowerShell ergonomics, including pipeline support, object-based usage, and easier ways to produce formatted console output and simple TUI interfaces.

Andree then explains that the module recently moved a significant amount of code into an internal C# project and added custom renderable objects. He notes that these changes also improved import speed and that the module now includes support for image rendering through several console protocols, including Sixel, Braille, half-cell blocks and canvas-based output.

A large part of the session focuses on documentation and testing. Andree shows how the module’s documentation website renders live examples from comment-based help, and he explains that the examples are generated automatically in the build pipeline. He also describes the ASCII Cinema recording format used for the website and how the module records Spectre output for these demos.

Andree then discusses the testing approach used for console rendering. He explains that Spectre.Console’s test console is used to capture output exactly, allowing byte-for-byte snapshot comparisons. He says this is important because Spectre performs terminal capability detection and color conversion, which makes output harder to test in a normal way.

Later, Andree walks through the module’s JSON and table formatting commands. He explains that the module handles pipeline input, simplifies objects before rendering, and performs several conversions so that PowerShell users do not need to work directly with Spectre’s more complex types. He also shows how table rendering inspects format data and VT escape sequences to convert and display text with Spectre colors.

Near the end, Andree demonstrates image rendering, color helpers, and a small TextMate-based code rendering module that integrates with Spectre objects. He closes by mentioning possible future work, including a rewrite in C# and solving module-loading issues around assembly load contexts.

Chapters:
00:00:00 Behind the Scenes of PwshSpectreConsole
00:00:15 Intro and Speaker Background
00:01:07 Spectre Console Overview
00:02:57 Internal Refactors
00:03:47 Docs and Live Examples
00:05:14 ASCII Cinema Recordings
00:09:23 JSON Formatting Internals
00:12:21 Table Formatting Deep Dive
00:25:37 Image Rendering Modes
00:28:55 Ergonomics and Color Handling
00:34:11 Rainbow Demo and Canvas
00:35:30 Testing and Snapshots
00:38:10 Terminal Profiles and CI
00:42:21 Unsupported Image Protocols
00:43:49 TextMate and Future PlansShow More

Behind the Scenes of PwshSpectreConsole - Andree Renneus - PSConfEU 2026

PowerShell Conference EU June 1-4, 2026 Dorint Pallas Wiesbaden ...

Caching - Accelerate your Code and Murder your Memory - Friedrich Weinmann - PSConfEU 2026

PowerShell Conference EU June 1-4, 2026 Dorint Pallas Wiesbaden ...

PowerShell Conference EU
June 1-4, 2026
Dorint Pallas Wiesbaden
https://github.com/psconfeu/2026 (slides, code)

This talk is about caching in PowerShell and the performance problems that arise when the same data is retrieved repeatedly. Fred introduces ...caching as storing data in memory so it does not need to be requested again, and starts with a simple example from Active Directory group membership reporting to show why repeated lookups can become slow.

He first demonstrates a basic cache built with a hashtable. In the example, group objects are stored after the first lookup and reused for later users, which reduces repeated calls and cuts execution time substantially. He then shows how a cache can be passed into a calling function as a parameter so it can be reused across multiple department reports instead of being recreated for each call.

Fred then turns to the main design concerns around caching. He discusses stale data, explaining that cached information can become incorrect if the source data changes. He also covers memory consumption, persistence, and concurrency, noting that caches can grow too large, disappear when the process ends, or create problems when multiple runspaces try to access the same data.

To address these issues, he presents a PowerShell class-based cache that tracks each item together with metadata such as timestamps. This allows the cache to enforce expiration and maximum item counts. He then improves the eviction strategy by linking cache entries with next and previous references, so the oldest entry can be removed without searching the whole collection.

The talk then moves to the PS Framework cache, which supports concurrent access from multiple runspaces. Fred shows expiration handling, automatic cleanup, and cache population through a script block that runs on read access when a value is missing. He also describes an option to dispose cached objects when they expire, with a warning that this can affect objects still used elsewhere.

In the final section, Fred discusses file-backed caching. He compares serialization options, explains the trade-offs between in-memory and disk-based storage, and shows how PS Framework uses compressed CLI XML. He finishes by describing file access coordination with mutexes and notes that the right cache design depends on the requirements for access, expiration, and sharing.

Chapters:
00:00:00 Caching - Accelerate your Code and Murder your Memory
00:00:19 Caching Basics
00:04:20 Hash Table Cache
00:06:42 Reusing the Cache
00:09:07 Cache Trade-offs
00:12:35 Building Smarter Cache
00:16:06 Scaling Bottlenecks
00:18:22 Fast Aging Cleanup
00:21:52 Concurrent Cache Access
00:23:41 Expiration and Cleanup
00:25:12 Lazy Loading Values
00:28:53 File-Backed Caching
00:35:09 File Locking Strategies
00:38:51 Mutex Questions
00:40:13 Choosing the Right CacheShow More

Make a PowerShell profile that runs on any version or platform - Sean Wheeler - PSConfEU 2026

PowerShell Conference EU June 1-4, 2026 Dorint Pallas Wiesbaden ...

PowerShell Conference EU
June 1-4, 2026
Dorint Pallas Wiesbaden
https://github.com/psconfeu/2026 (slides, code)

Sean Wheeler introduces the session by explaining that the talk focuses on scripting defensively so that PowerShell scripts work across platforms and ...versions, using a profile as the main example. He briefly describes his role at Microsoft and notes that the presentation materials and demo scripts are available on his website.

He then explains the basics of PowerShell profiles. He describes the different profile scopes, how PowerShell checks them in order, and how the last one that runs determines the final settings. He also shows how profile paths are created and how the $profile variable contains note properties for the different profile locations.

A large part of the session compares PowerShell 5.1 and PowerShell 7. Sean points out differences in available variables, cmdlets, parameter sets, escape sequences, experimental features, and newer operators such as the pipeline conditionals, ternary operator and null-coalescing operator. He also notes that some features, such as ANSI escape sequences, work differently or require alternate approaches in Windows PowerShell.

He then moves to platform differences between Windows and non-Windows systems. He discusses Windows-only features such as execution policy and certain cmdlets, as well as cross-platform concerns like path separators, invalid filename characters, line endings and case sensitivity in environment variables. He also explains that many Windows convenience aliases do not exist on Linux, because commands behave differently there.

The talk also covers host differences, including Console Host, VS Code, Windows PowerShell ISE and the PowerShell extension terminal. Sean explains that checking $host can be misleading and that PSVersionTable gives the actual PowerShell version. He notes that different hosts can have different capabilities and quirks.

In the final part, Sean shows defensive configuration techniques for profiles, including PSDefaultParameterValues, Out-Default variable capture, prompt customization and consistent PSReadLine key bindings across systems. He also describes how he keeps profile scripts synchronized and warns against storing modules or Git repositories in OneDrive folders.

Chapters:
00:00:00 Make a PowerShell profile that runs on any version or platform
00:00:20 Welcome and Overview
00:01:42 Defensive Scripting Basics
00:07:26 Profile Files and Versions
00:16:27 PowerShell 7 New Syntax
00:22:06 Platform-Specific Limits
00:32:27 Host and Console Differences
00:35:19 Environment Setup Tips
00:41:47 Custom Defaults and KeymapsShow More

PowerShell: Designed for a Messy World - Jeffrey Snover - PSConfEU 2026

PowerShell Conference EU June 1-4, 2026 Dorint Pallas Wiesbaden ...

PowerShell Conference EU
June 1-4, 2026
Dorint Pallas Wiesbaden
https://github.com/psconfeu/2026 (slides, code)

Jeffrey Snover begins by describing the history of PowerShell and the messy environment in which it was created. He says PowerShell was ...designed for a world full of legacy systems, broken tools, inconsistent vendor implementations and changing requirements, and that the team expected Microsoft itself would not solve those problems for users.

He then explains that this shaped the original architecture of PowerShell. The goal was to give people tools that could help them solve problems themselves, with a strong focus on extensibility, remoting, security and consistent management. He describes the Monad Manifesto as an early document that laid out this direction, including the idea of an automation shell, a management framework and a common user experience.

Snover next walks through the core design of the PowerShell engine. He says the engine is a library that can be hosted in different environments, and that cmdlets are organized around a single parser, common runtime, and metadata-driven behavior. He also explains that PowerShell normalizes messy type systems, converts between formats, and reduces the need for developers to build their own parsers.

A major theme of the talk is the object pipeline. He explains that PowerShell differs from Unix-style pipelines because it works on objects rather than text, and that commands are designed to preserve objects instead of forcing users to reconstruct them later. He connects this to cmdlets such as `where`, which he describes as assigning the current pipeline object to a variable and evaluating a script block as true or false.

He also highlights built-in mechanisms such as `ShouldProcess`, `-WhatIf`, and `-Confirm`, and says these features make commands safer and more consistent. He describes how formatting, exporting, remoting and providers are handled by the engine, so authors can write less code while still getting a richer system.

In the later part of the lecture, Snover argues that PowerShell’s purpose is to make users more effective and more valuable. He says the platform has steadily lowered the barrier to entry through modules, auto-loading, DSC, the community gallery and open source development, and he encourages using large language models to work with advanced PowerShell features more easily.

Chapters:
00:00:00 PowerShell: Designed for a Messy World
00:00:19 PowerShell’s Origin Story
00:02:09 Messy World, Messy Tools
00:09:52 Designing for Failure
00:14:30 The Monad Vision
00:17:33 Architecture of Hosts
00:21:36 Normalizing Broken Systems
00:30:24 Object Pipelines, Not Files
00:34:01 Functional Units and Leverage
00:40:33 Should Process and Where
00:46:29 AI for PowerShell Extensions
00:51:21 From Scripts to Open Source
00:53:43 Making Admins More ValuableShow More

Automate your upstream sync with GitHub Copilot and PowerShell MCP - Tess Gauthier - PSConfEU 2026

PowerShell Conference EU June 1-4, 2026 Dorint Pallas Wiesbaden ...

PowerShell Conference EU
June 1-4, 2026
Dorint Pallas Wiesbaden
https://github.com/psconfeu/2026 (slides, code)

Tess introduces the talk as a walkthrough of automating upstream sync for OpenSSH for Windows using GitHub Copilot, PowerShell MCP, and an ...AI agent. She explains that the repository is a fork of OpenBSD’s OpenSSH portable repository with Windows-specific compatibility changes, and that keeping it aligned with upstream is difficult because upstream changes regularly and the merge process can introduce conflicts.

She then outlines the current maintenance workflow. The process begins by merging the latest upstream tag, resolving conflicts, updating project files when files have been added or removed, rebuilding the solution, and fixing compilation issues or warnings. After that, the team runs local validation, followed by fuller CI-based testing.

Tess explains how the AI-assisted workflow was set up with an MCP server and PowerShell scripts. The agent is given instructions for the merge phases, including prerequisites, merge, build, and validation, along with an initial prompt that supplies the upstream tag information needed to start. Repository-wide instructions and merge-specific guidance describe common conflict patterns and how to handle them.

She then describes the tools used in each phase. A prerequisites tool checks that the machine has the right development setup, that the repository is configured correctly, and that the working tree is clean. A commit-grouping tool retrieves upstream commits in batches based on CI runs so the agent is not overwhelmed by too much context at once. Another tool provides extra diff context for difficult conflicts, and the instructions include guardrails that let the agent stop and ask for help when a merge looks too complex.

The build phase reuses the existing OpenSSH build script through MCP. Tess notes that a separate tool reads build logs so the agent can tell whether a build really succeeded, not just whether the command exited cleanly. She also explains that builds are required for source-code changes, but some documentation or CI-only changes can skip that step.

In the validation phase, the agent sets up a local SSH server, creates a temporary user, and runs a non-interactive SSH command as a success check. Tess says the workflow ends with a summary of merged commits and changes, which could later be written to a markdown file and reviewed by a person or another agent. She closes by emphasizing smaller tasks, clear success criteria, and reusing existing scripts as the main lessons from the experiment.

Chapters:
00:00:00 Automate your upstream sync with GitHub Copilot and PowerShell MCP - Tess Gauthier - PSConfEU 2026
00:00:21 Opening and Repository Overview
00:03:21 Current Merge Workflow
00:04:45 MCP Tools and Agent Setup
00:07:27 Prerequisites and Commit Batching
00:11:45 Build Phase Automation
00:14:29 Local Validation Checks
00:16:52 Demo of the Agent
00:23:55 Key Takeaways and Future Vision
00:26:14 Model Choices and Experimentation
00:28:15 Staying in Sync
00:28:55 Conflict Patterns and Limits
00:30:05 Commit Chunking Strategy
00:34:37 Testing vs ValidationShow More

Lists, Dictionaries, or Arrays – Where the Heck Should I Store My Data? - Christian Ritter - …

This lecture is a practical guide to storing data in PowerShell, with ...

This lecture is a practical guide to storing data in PowerShell, with a focus on arrays, lists, dictionaries, queues, stacks, hash sets and priority queues. Christian Ritter introduces the session ...by outlining the topics and then moves directly into code examples.

He begins with arrays, showing several ways to create them, including comma-separated values, ranges and output from a loop. He explains indexing, including negative indexes for accessing elements from the end, and notes that arrays are not strongly typed. He also discusses extending arrays and points out that adding with `+=` copies the array and can be inefficient.

Christian then compares arrays with generic lists. He shows that lists avoid repeated reallocation, can be given an initial capacity, and support strongly typed values. He also demonstrates that `ArrayList` is not type safe and can lead to unexpected return values when mixed types are added. He shows copying lists, reassigning references and slicing a list to create a copy of a range.

The lecture then covers dictionaries and hash tables. Christian explains key-value access, updating and removing entries, iterating through entries, and using `ContainsKey`. He compares unordered hash tables with ordered dictionaries, and shows how generic dictionaries add type safety and can be made case-insensitive with a string comparer.

He next presents queues and stacks. Queues are shown as first-in, first-out collections with `Enqueue`, `Dequeue` and `Peek`, including a small example that stops and resumes processing. Stacks are presented as last-in, first-out collections, with a real-life example based on undo history.

Finally, Christian discusses hash sets and priority queues. He demonstrates how hash sets prevent duplicates and support union, intersection and difference operations. He then shows a priority queue with custom ordering, using priority and timestamp to control dequeue order. In the closing part, he briefly covers lookup methods and concurrent dictionaries for parallel work, noting that concurrent collections help avoid race conditions when adding items from multiple threads.

Chapters:
00:00:00 Lists, Dictionaries, or Arrays – Where the Heck Should I Store My Data? - Christian Ritter - …
00:00:15 Data Structures Overview
00:01:43 Arrays and Memory Costs
00:06:10 Lists and Strong Typing
00:07:14 ArrayList Pitfalls
00:13:46 Copying and Slicing Lists
00:14:16 Dictionaries and Lookup Speed
00:17:54 Ordered and Generic Dictionaries
00:20:04 Queues and Peek Operations
00:23:37 Stacks and Undo History
00:24:53 Hash Sets and Uniqueness
00:29:05 Priority Queues Explained
00:33:20 Lookup Tricks for Fast Search
00:39:14 Concurrent Dictionaries in ParallelShow More

Musical PowerShell - Make your scripts sound awesome! - Björn Sundling - PSConfEU 2026

PowerShell Conference EU June 1-4, 2026 Dorint Pallas Wiesbaden ...

PowerShell Conference EU
June 1-4, 2026
Dorint Pallas Wiesbaden
https://github.com/psconfeu/2026 (slides, code)

Björn Sundling introduces the session as a musical PowerShell talk and explains that the topic is MIDI. He gives brief background on ...MIDI as a protocol from 1983 for instrument-to-instrument communication, and notes that MIDI 2.0 was released in 2020. He also explains that the newer Windows MIDI support includes a PowerShell module, which is the main reason he became interested in the topic.

He then demonstrates how to start MIDI in PowerShell, list connected devices, create loopback endpoints and open a session. Using the module, he sends MIDI 1.0 and MIDI 2.0 messages to produce sound from PowerShell. He describes how he first had to understand the message format, including groups, status messages, note numbers and attributes, and shows how those values map to binary and integer representations.

Björn next explains how he built helper classes and a wrapper around the MIDI message builder so that notes can be created more easily from names such as C3 instead of bit shifting and manual calculations. He extends this approach to chords by sending multiple messages at once, and then begins exploring how to build drum patterns and metronomes.

He discusses several timing approaches, including while loops and PowerShell timers, and explains that they were not accurate enough for music. He then describes a custom metronome built around MIDI clock timing and later moving the work into thread jobs so the console stays usable. To share data between threads, he experiments with thread-safe collections and eventually uses a list or dictionary-based queue to inject events in the correct order.

The talk then shifts to receiving MIDI input. Björn registers event handlers, filters noisy messages and maps MIDI note values to ASCII characters. He wraps this in a virtual keyboard so MIDI keys can type into other windows, and shows a script that converts its own characters into notes, producing “the sound of my code.”

In closing, he notes that the same ideas can be applied to other control systems, such as DMX lighting, custom controllers and other devices. He says the project taught him about timing, queues and thread safety, and ends with a brief question-and-answer discussion about ordering, timing limits and time signatures.

Chapters:
00:00:00 Musical PowerShell - Make your scripts sound awesome!
00:00:22 Musical PowerShell Begins
00:02:33 MIDI's Origins and Standards
00:05:56 PowerShell Meets MIDI 2.0
00:07:26 Sending the First Notes
00:10:06 Decoding MIDI Messages
00:14:04 Building Chords and Helpers
00:15:50 Drums, Beats, and Timing
00:17:12 Fixing the Metronome
00:22:41 Sharing Data Across Threads
00:28:01 Reading MIDI Input
00:30:49 ASCII as a Keyboard
00:33:35 Making Code Sound Music
00:35:17 Practical Uses Beyond Music
00:39:46 Questions and Final ThoughtsShow More

Beyond Scripts: Extending Azure SRE Agent with PowerShell Automation - Jan Egil Ring - PSConfEU 2026

This session introduced Azure SRE Agent and how it can be extended ...

This session introduced Azure SRE Agent and how it can be extended with PowerShell automation. Jan explained that the demo focused on incident response, drift detection and ways to connect ...PowerShell code to the agent through MCP. He also outlined the environments used in the examples, including Azure Automation, Logic Apps and PowerShell Universal.

He then described the problem space for SRE work, where incidents must be triaged quickly and teams need good runbooks and documentation. The talk framed Azure SRE Agent as a service that can gather context, query Azure Monitor, analyse logs and metrics, and reason about possible causes. Jan also said the agent can be configured with different permissions, so it may only read information or also perform remediation.

A major part of the session covered MCP as the protocol used to expose tools to the agent. Jan showed how PowerShell-related actions can be wrapped behind MCP servers, either through Azure Automation runbooks, Logic Apps with inline PowerShell, or PowerShell Universal scripts. He explained that these approaches let the agent call into custom automation while keeping the implementation in PowerShell.

Jan then walked through the demo environment and repository. He showed a web application used to simulate errors and latency, alert rules created with Bicep, and runbooks that scale an App Service plan when an incident occurs. The repository also included documentation in Markdown so the agent could use architecture notes and other context during investigation.

Later, Jan demonstrated the agent portal and the setup process, including incident sources, documentation, code repositories and connectors. He showed how the agent acknowledged an Azure Monitor alert, created an incident, read the runbook guide and used Azure CLI to inspect the current state. He also described the onboarding process, where the agent gathers team knowledge and stores context for later use.

The session concluded with the remediation flow, where a custom MCP tool called a Logic App, which then triggered an Azure Automation runbook to change the App Service SKU. Jan also showed Teams notifications with links back to the alert and incident thread, and a drift-detection example using scheduled tasks.

Chapters:
00:00:00 Beyond Scripts: Extending Azure SRE Agent with PowerShell Automation - Jan Egil Ring - PSConfEU…
00:00:18 Azure SRE Agent Intro
00:02:43 Incident Response Challenges
00:05:20 What Azure SRE Agent Does
00:09:10 PowerShell Integration Patterns
00:11:37 Demo Environment Overview
00:17:25 Portal Setup and Onboarding
00:22:33 Live Incident Remediation
00:26:50 MCP Tools and Reasoning
00:30:37 Agent Instructions and Skills
00:36:08 Connector and Tool Setup
00:38:14 Logic App Workflow MCP
00:41:27 Runbooks and Guardrails
00:43:26 Drift Detection AutomationShow More

2026

Behind the Scenes of PwshSpectreConsole - Andree Renneus - PSConfEU 2026

Have a look at the PSConfEU 2026 schedule!

Like this:

Contact info

Join the PSConfEU Community!

Additional links

2026

Behind the Scenes of PwshSpectreConsole - Andree Renneus - PSConfEU 2026

Have a look at the PSConfEU 2026 schedule!

Share this:

Like this: