Another NotebookLM job. Bit of a rush, only 73 sources.
Had a request to get a WPF tool working on a Mac. Not important, but a chance to grow my skillz. So Here's the first of two covering it.

Notebook LM Prompt:

```
This is Episode 10 of News Re-Download, a podcast talking about software engineering. We're going over how to migrate a dot net 8 WPF app to dot net MAUI without losing the WPF build. We want a project with two front ends so we can explore growing from WPF developers, to XAML developers.
### Concise Guide: .NET MAUI Windows Frontend & Auto-Update Deployment
**1. Architecture & Project Setup**
*   **Create Project:** Add a new .NET MAUI App named `JiraMinion.MAUI` to your solution, targeting Windows. 
*   **Link Shared Logic:** Add a project reference to `JiraMinion.Shared` so you can reuse all ViewModels and business logic.
*   **Dependency Injection:** Register your shared ViewModels and MAUI-specific services in the `MauiProgram.cs` bootstrap class.
**2. Translating the UI (XAML Migration)**
WPF and MAUI XAML cannot be shared directly because MAUI uses the 2009 XAML specification, and its controls derive from `VisualElement` instead of `FrameworkElement`.
*   **Control Mapping:** Translate `Window` to `ContentPage`, `StackPanel` to `VerticalStackLayout` or `HorizontalStackLayout`, `TextBlock` to `Label`, and `TextBox` to `Entry` (single-line) or `Editor` (multi-line).
*   **Layout & Alignment:** Replace `HorizontalAlignment` with `HorizontalOptions` using values like `Start`, `Center`, or `Fill`.
*   **Data Binding:** MAUI uses Compiled Bindings by default for better performance. You must explicitly set `x:DataType` on your data templates. `RelativeSource` bindings (like `FindAncestor`) are much stricter in MAUI; if visual tree boundaries break, use `x:Reference` to target named elements instead.
**3. Platform-Specific Services**
*   **Cross-Platform APIs:** Replace your WPF Win32 service implementations with MAUI's built-in abstractions. Use the `Microsoft.Maui.ApplicationModel.DataTransfer.Clipboard` API for your `IClipboardService` and `Microsoft.Maui.ApplicationModel.Launcher.OpenAsync` for your `IBrowserService`.
*   **Native Windows Code:** If you must use Windows-specific APIs (like the Windows Registry), place that code inside the `Platforms/Windows/` directory or use conditional compilation (`#if WINDOWS`) so it only compiles for the Windows build.
**4. Deployment (ClickOnce Equivalent)**
ClickOnce does not translate to MAUI's multi-platform packaging. The modern equivalent for Windows is **MSIX combined with an AppInstaller file**, which provides the exact same automatic update on launch experience.
*   **Publish the MSIX:** Build and publish your MAUI app as an `.msix` package.
*   **Create the `.appinstaller` File:** Create an XML file hosted on your network share that points to the network URI of the latest MSIX package.
*   **Configure Auto-Updates:** In the AppInstaller XML, include an `` block with ``. This instructs Windows to check the network share for a new version every time the user opens the application, applying updates automatically. Users install the app initially by running this `.appinstaller` file.
```

This episode includes AI-generated content.

We're looking at Stack Panels, Flex Box and the other UI elements to are part of layouts and achieving a fluid UI. Elements like the canvas that do absolute positioning are part of next week's episode.

177 Sources for his episode.

Here's the prompt from Notebook LM. 

---


# Summary
This is episode 009 of the podcast. And this Episode is 02 of a special mini series called “UI Rosetta Stone”.
Focus: Exploring how different UI frameworks handle fluid, responsive element placement using layout panels, and how these layouts dynamically adapt to diverse physical hardware through pixel density and DPI scaling algorithms.
Audience: UI engineers, cross-domain.

## 009: StackPanels & Fluid Layouts
    UI Rosetta Stone 02: 
• One-Dimensional vs Two-Dimensional Layouts (StackPanels, Flexbox, Grids)
• Fluid Design and Responsive Spaces
• Pixel Density, DPI Scaling, and Screen Adaptation


## Must cover:
This is the key information to be presented this episode, and MUST be covered!
- The concept of "Fluid Design": UIs that gracefully handle elements appearing/disappearing and adjust across various monitor environments like 1080p, 1440p, 4K, and ultrawide screens.
- Pixel density and resolution independence: Contrast building for a flagship retina display phone vs. a large, low-resolution industrial/factory monitor. Explain the cross-domain solutions: Device-Independent Pixels (DIPs) in WPF, DPI Scaling Curve rules in Unreal Engine, and `devicePixelRatio` in React/Web.
- One-Dimensional Layouts: Explain the **StackPanel** (WPF), **Flexbox** (`flex-direction: row` or `column` in React), and **Horizontal Box / Vertical Box** (UMG). 
- Controlling space in 1D layouts: Compare UMG's "Auto" (size to content) vs "Fill" (take remaining space) to React's `flex-basis`, `flex-grow`, and `flex-shrink` properties.
- Two-Dimensional Layouts: Contrast the **Grid** in WPF (using Star `*` sizing), **CSS Grid** in React (using `fr` fractional units), and the **Grid Panel / Uniform Grid** in UMG.
- Other specialized panels: Handling content flow using WPF's **WrapPanel** versus React's `flex-wrap`, and pinning elements to container edges using the WPF **DockPanel**.

## Topics already covered:
This is information already covered in previous episodes or coming up in future episodes, and you cannot cover it again. For reference, I have provided the episodes where it was spoken of, and you may ask listeners to go back.
- 00: WPF Runtime and dispatcher
- 00: Unreal runtime and what slate is
- 00: Web runtime and browser DOM + Javascript engine + Node Server
- 00: Dev environments, Visual studio vs unreal vs visual studio code
- 00: Source control, Git, perforce etc…
- 01: Definition of a control, user control, component etc…
- 01: Button element\control and Textbox\label controls
- 01: MVVM and importance of separation of concerns
- 02: Layout controls that are not "panels" including overlay, canvas

## Rules:
- Keep it controls-level, not engine internals.
- Give concrete mental models, not buzzwords. (e.g., Explain Flexbox/StackPanel as "beads on a string" that push against each other, Grids as a "spreadsheet", and DPI scaling as a global "magnifying glass" translating software units to physical monitor pixels).

This episode includes AI-generated content.

We're starting with basic controls. The label and the button to examine the design patterns and architecture behind the implementations in React, WPF and UMG.

177 Sources for his episode.

Here's the prompt from Notebook LM. 

---

This is special Episode 001 of “UI Rosetta Stone”.
Focus: introduce the series using the simplest controls (Button + Label/Text) to explain core patterns.
Audience: UI engineers, cross-domain.
Must cover:
- What a “control” is in each ecosystem (composition vs inheritance, templating/styling model at a high level).
- Button: input/click handling, focus/keyboard/controller considerations (high level), and where logic belongs.
- Label/Text: static text, localization concerns (high level), and render cost awareness.
- WYSIWYG workflows:
  - WPF/XAML designer reality (and when people abandon it)
  - Unreal UMG Designer + preview quirks
  - Web: browser + component preview tooling mindset
- Patterns crosswalk:
  - MVVM in WPF/Noesis: bindings, change notification, commands
  - Unreal MVVM plugin: bindings + FieldNotify conceptually
  - React: props/state, unidirectional flow, “components as functions of state”
- Best practices + common traps when porting habits between stacks (explicit callouts).

Rules:
- Keep it controls-level, not engine internals.
- Give concrete mental models, not buzzwords.


This episode includes AI-generated content.

In this sub-series, I'm normalizing knowledge between WPF, UMG and React UI by going over their concepts together in a head to head to head comparison. 

Again, this is Notebook LM. 101 References on this one. I had to trim the first few minutes with Audacity as my prompt oversteered and produced a bunch of weird repitition and junk. I mispelt my meta-prompt I gave to chatGPT to produce the prompt I gave to Notebook LM.

Here's the prompt:

```
You are writing Podcast Episode 000 for a special mini-series called “UI Rosetta Stone”.
Audience: experienced UI devs coming from WPF/XAML, Unreal UMG/Slate, and React/web.
Goal: explain the *runtime + tooling* model for each stack at a “controls and workflow” level (not deep engine internals).
Tone: direct, practical, engineering-first. Assume middle to senior devs.
Must cover:
- WPF runtime: .NET CLR, Dispatcher/UI thread, layout+render pipeline at a high level, app executable + OS integration.
- Unreal runtime: what Slate is, how UMG sits on top, game loop + frame budget context, PIE vs packaged build.
- Web runtime: browser JS engine (V8/SpiderMonkey/etc), DOM/CSS/layout, React on top, plus Node/server accessed via browser.
- Debugging in each: Visual Studio debugger + WPF inspection tools; Unreal Widget Reflector/Slate tools + logs; browser DevTools + React DevTools.
- Dev environments: Visual Studio vs VS Code vs Unreal Editor tooling, typical iteration loops.
- Source control workflows: git, Perforce, SVN, Mercurial — where each commonly appears and why (big binaries, branching, CI realities).
Output format:
1) Title
2) 2–3 sentence episode synopsis
3) Segment outline with timestamps (rough)
4) Full narration script (spoken-word, no code)
5) “Crosswalk” table: concept → WPF term → Unreal term → Web/React term
6) Show notes: bullets + key terms glossary
Rules:
- Don’t invent specific tool feature claims you’re unsure about. If uncertain, write “(verify)” inline.
- Keep examples conceptual (no code).


```



This episode includes AI-generated content.

Another one from notebook lm. Its 136 sources. Im setting up a RAG servee at work and need to know more about local models due to security restrictions. 

below is my prompt:

---

System Role: Act as an AI Infrastructure Engineer and generate an actionable research report based strictly on Hugging Face data (model cards, discussions, metrics) for local GGUF models running via LM Studio/llama.cpp on Windows.
Target Use Case: Software engineering (C, C++, C#, Lua, Unreal Blueprints, Unity YAML) and local RAG.
Hardware Targets: Tier A (10GB VRAM / RTX 3080), Tier B (24GB VRAM / RTX 3090), Tier C (48GB VRAM / Pro GPU).
Required Deliverables:
Model Taxonomy & Lineage: Define current classes (Generative LLMs, Embeddings, Rerankers, Vision) mapping to LM Studio UI. Detail provenance for major architectures (e.g., Llama, Mistral, Qwen, Phi).
Tiered Model Shortlist: Top coding/generalist models per VRAM tier. Specify exact HF name, parameter count, Q4_K_M/Q5_K_M VRAM footprint, recommended vs. max context windows, and HF download/like metrics (with dates).
Throughput Metrics (Tokens/sec): Provide throughput estimates per GPU tier. Compare Q4 vs Q5 performance. Include test parameters (context length, batch size, prompt vs. gen mix).
Mini-Guides (Code & RAG): For each model, detail: strengths/failure modes, context degradation thresholds (10k+ lines), chunking strategies, and optimal LM Studio sampling configurations (temperature, top_p, min_p, repetition penalty).
Memory & Scaling Architecture: * Clarify LM Studio multi-model placement (CPU vs GPU offloading interactions).
Deploy A: Single GPU optimization.
Deploy B: 48GB Multi-GPU pro server (Compare vLLM vs TensorRT-LLM vs llama.cpp; explain tensor/pipeline parallelism penalties).
Deploy C: 6x8GB commodity rig OS/software strategies.
KPIs & Capabilities: Define capacity metrics (TTFT, concurrency, queue depth). Quantify the throughput penalty vs. quality gain of "reasoning" models. Explain the mechanical reality of file/image attachments (native multimodality vs text conversion).

This episode includes AI-generated content.

I'm trying to get better at optimization and strategies. So here's a bunch of research (62 sources) from lm studio.

And here's the prompt:

"Write me a guide on how to profile the HUD in an unreal game. It's unreal 5.6, and HEAVY use of widget blueprints. I'm using the MVVM plugin from Epic, as well as Common UI and the Preview plugin.So my current strategy is to use the automation driver in unreal engine to simulate input in an automated test. This gets me reliable and predictable play sessions I can then profile with unreal insights. I get big fat files from this, but I also want to do lighter weight stuff and push it to a server to get graphs and stuff.
Walk me through a good profiling setup, and then into interpreting the data and enacting change. Include stuff to boost performance. Like how the bindings unreal added several years ago sucks, and how the new visual bindings are awesome."


This episode includes AI-generated content.

This is generated by notebook LM, from my "Software Audit" project. 183 references to licensing and audit sources. The goal here is to learn more about being proffesional, and avoiding SOUP and copy left licenses. This was inspired an S-Tier talk at GCAP 2025.

So here's the prompt I entered:

"
I'm a software engineer that wants to level up my skills into the boring world of audits and compliance. It's dull, and I just like making stuff. But I'm a proffesional, who ships software used by business and video game studios. I do not want to find out something went bad because a line of code had legal implications, or some viral copyleft license caused a game I'm working on to get delayed by months because I was stressed and solved a Jira ticket in the wrong way.
This is all new to me. I know about SOUP code, and Copy-Left viral licenses. I've thrown together an SBOM document. But I need a shallow and broad overview of the world of compliance and audits. I can't articulate my knowledge shortcomings because I do not know enough.
Give me the full 101 on audits and compliance. Go through tooling, pitfalls, report types and everything else.
End with a hypothetical tour of bringing a filthy codebase up to a clean respectable standard. In the hypothetical, every mistake has been made, and I want you to talk about how to correct every single one, including the heavy painful costs of the bad mistakes being rectified. 
I want to know the landscape, the way to clean code and the consequences for failure.
My environment is Windows, my code is C++ via unreal engine, and C# via WPF and asp.net, and typescript via NodeJs. Use examples specific to me please, but go beyond that where it helps get your information across.

"

This episode includes AI-generated content.

Generated by NotebookLM using 40 sources, including some software design spec sheets for new features. It's about the MVVM plugin for Unreal, written to assist a XAML UI engineer in upskilling in Unreal UMG.

Here's the prompt I fed NotebookLM to generate this:

Generate a podcast episode outline and conversational prompt for a general-audience, technically curious listener.
Format
Two speakers:
Expert: senior Unreal UI engineer who’s calm, precise, and explains concepts with simple analogies.
Learner: competent developer who’s been duplicating UI behaviour across widgets and is frustrated by inheritance limits.
Tone: friendly, nerdy, practical. No arguing. No hype.
Length target: 15–25 minutes.
Scenario
The Learner has been building a UI library and keeps re-implementing the same “preview/mock data” and lifecycle glue in multiple widget types. They tried to solve it with base classes, but hit the wall: some widgets don’t share ancestry (e.g., user widgets vs buttons). They discovered Unreal’s MVVM plugin and noticed it uses a thing called a widget extension (via UUserWidgetExtension, with UMVVMView as an example). They want to know if this is the right pattern to avoid inheritance sprawl.
Goals for the episode
Explain the problem: why “big base class” inheritance breaks down in UI libraries.
Introduce the concept: what widget extensions are in Unreal (composition over inheritance) and how the MVVM plugin uses them.
Clarify the constraints: extensions attach to user widgets, not every primitive widget type; what that means in practice.
Give a practical mental model using non-Unreal comparisons:
“attached behaviours” (WPF/Blend style),
“components” (Actor-Component style),
“mixins” (conceptually, but not literally).
Walk through a high-level implementation plan for a custom extension:
purpose (e.g., “design-time mock view-model instantiation”),
lifecycle hooks and when they run (editor vs runtime),
how a widget finds/uses the extension.
Cover 2–3 “gotchas” without deep rabbit holes:
initialization order / “too late to add” issues,
editor hot reload quirks,
how to keep extensions small and focused to avoid a new monolith.
Outcome: Learner leaves with a clear decision tree:
when to use an extension,
when to wrap primitives in a user widget,
when to use a plain helper object instead.


This episode includes AI-generated content.

Using NotebookLM by google, this is generated podcast episode coming from 112 sources. 
It's a comparison of five different TTS technologies. Below is the prompt used to generate this:

Prompt:
I need a report comparing VITS, Coqui TTS, Chatterbox, Elevenlabs and Qwen3 TTS.
Got through all of these sequentially and inform me on how to use them, their advantages and their pain points.
In conclusion, recommend which suits my project best.



This episode includes AI-generated content.

A five-minute blast of the biggest VR stories from mid-April:

• Sony hikes PlayStation 5 prices outside the US.
• Meta Quest 3 S gets a limited-time USD $30 discount (plus Quest Plus + Batman: Arkham Shadow).
• US tariffs on electronics are briefly lifted, giving headset makers a reprieve.
• Modders unlock adaptive triggers, eye-tracking and partial HDR for PS VR 2 on PC.
• NVIDIA RTX 5060 debuts—with RTX 2080-class VR performance for just USD $300.

Rapid-fire extras: REC turns esports into real-robot combat, James Cameron praises VR headsets for 3-D film, DeeMio upgrades Vision Pro support, and rumors swirl about Apple’s lighter M5-powered headset.

Please find the full episode here:
https://www.uploadvr.com/podcasts/

This episode includes AI-generated content.