Tag Archives: howto

How to convert a Markdown file to Word document with PowerShell: A One-Line Solution

Overview

Need to convert Markdown files to Word documents quickly and efficiently? 

This one line PowerShell leverages the Word COM object to transform your .md files into professionally formatted .docx documents – no external tools or dependencies required.

The Solution

This script provides a complete Markdown-to-Word converter that handles all common formatting elements. Simply update the file path, paste into PowerShell, and execute.

$mdPath = "C:\Users\Documents\report.md"; if (-not (Test-Path $mdPath)) { Write-Error "❌ Markdown file not found at: $mdPath"; return }; $docPath = [System.IO.Path]::ChangeExtension($mdPath, ".docx"); function Process-InlineFormatting { param($range, $text); $position = 0; $segments = @(); while ($position -lt $text.Length) { if ($text.Substring($position) -match '^\*\*\*(.+?)\*\*\*') { $segments += @{Text = $matches[1]; Bold = $true; Italic = $true}; $position += $matches[0].Length } elseif ($text.Substring($position) -match '^\*\*(.+?)\*\*') { $segments += @{Text = $matches[1]; Bold = $true; Italic = $false}; $position += $matches[0].Length } elseif ($text.Substring($position) -match '^\*(.+?)\*') { $segments += @{Text = $matches[1]; Bold = $false; Italic = $true}; $position += $matches[0].Length } else { $nextAsterisk = $text.IndexOf('*', $position); if ($nextAsterisk -eq -1) { $segments += @{Text = $text.Substring($position); Bold = $false; Italic = $false}; break } else { $segments += @{Text = $text.Substring($position, $nextAsterisk - $position); Bold = $false; Italic = $false}; $position = $nextAsterisk } } }; foreach ($segment in $segments) { if ($segment.Text) { $range.Text = $segment.Text; $range.Font.Bold = $segment.Bold; $range.Font.Italic = $segment.Italic; $range.Collapse(0) } } }; try { $word = New-Object -ComObject Word.Application; $word.Visible = $false; $doc = $word.Documents.Add(); $lines = Get-Content $mdPath -Encoding UTF8; $wdCollapseEnd = 0; $wdBorderBottom = 4; $wdLineStyleSingle = 1; $wdColorBlack = 0; $wdLineWidth150pt = 6; foreach ($line in $lines) { $range = $doc.Content; $range.Collapse($wdCollapseEnd); if ($line -match '^\s*$') { $range.Text = "`r"; $range.Style = "Normal"; continue }; if ($line -match '^\s*[-]{3,}\s*$') { $range.Text = "`r"; $range.Style = "Normal"; $range.ParagraphFormat.Borders.Item($wdBorderBottom).LineStyle = $wdLineStyleSingle; $range.ParagraphFormat.Borders.Item($wdBorderBottom).Color = $wdColorBlack; $range.ParagraphFormat.Borders.Item($wdBorderBottom).LineWidth = $wdLineWidth150pt } elseif ($line -match '^(#{1,6})\s+(.+)') { $headerLevel = $matches[1].Length; $headerText = $matches[2]; Process-InlineFormatting -range $range -text $headerText; $range.Style = "Heading $headerLevel"; $range.Collapse($wdCollapseEnd); $range.Text = "`r" } elseif ($line -match '^\s*[-*+]\s+(.+)') { $listText = $matches[1]; Process-InlineFormatting -range $range -text $listText; $range.Style = "List Bullet"; $range.Collapse($wdCollapseEnd); $range.Text = "`r" } elseif ($line -match '^\s*\d+\.\s+(.+)') { $listText = $matches[1]; Process-InlineFormatting -range $range -text $listText; $range.Style = "List Number"; $range.Collapse($wdCollapseEnd); $range.Text = "`r" } else { Process-InlineFormatting -range $range -text $line; $range.Style = "Normal"; $range.Collapse($wdCollapseEnd); $range.Text = "`r" } }; $doc.SaveAs([ref] $docPath); $doc.Close(); $word.Quit(); [System.Runtime.Interopservices.Marshal]::ReleaseComObject($word) | Out-Null; [System.GC]::Collect(); [System.GC]::WaitForPendingFinalizers(); Write-Host "✅ Markdown converted to Word document at $docPath" } catch { Write-Error "❌ An error occurred: $_"; if ($doc) { $doc.Close($false) }; if ($word) { $word.Quit(); [System.Runtime.Interopservices.Marshal]::ReleaseComObject($word) | Out-Null } }

How to Use

Step 1: Update the file path at the beginning of the script

$mdPath = "C:\Users\Documents\report.md"

Step 2: Copy the entire one-line script above

Step 3: Paste into PowerShell and press Enter

Step 4: Your Word document will be created in the same directory with a .docx extension

Supported Markdown Features

The script converts the following Markdown elements to their Word equivalents:

Headers

markdownDownloadCopy code# Heading 1
## Heading 2
### Heading 3

Converts to Word’s built-in Heading 1, 2, 3 styles (up to Heading 6)

Text Formatting

  • Bold: **text** → text
  • Italic: *text* → text
  • Bold + Italic: ***text*** → text

Lists

Bullet Lists:

markdownDownloadCopy code- Item one
* Item two
+ Item three

Numbered Lists:

markdownDownloadCopy code1. First item
2. Second item
3. Third item

Horizontal Rules

markdownDownloadCopy code---

Creates a horizontal line with bottom border formatting

Special Characters

UTF-8 encoding support ensures proper handling of international characters, accents, and special symbols.

How It Works

Inline Formatting Parser

The script includes a custom function that processes inline formatting by:

  1. Parsing text character-by-character
  2. Identifying markdown formatting markers (******)
  3. Extracting the text within markers
  4. Applying appropriate Word formatting (Bold, Italic, or both)
  5. Removing the markdown syntax

Document Processing

The script:

  • Reads the markdown file with UTF-8 encoding
  • Processes each line sequentially
  • Applies regex pattern matching to identify markdown elements
  • Uses Word COM object methods to apply appropriate styles
  • Handles blank lines to preserve document spacing
  • Properly manages Word styles to prevent formatting conflicts

COM Object Management

The script properly initializes and cleans up Word COM objects to prevent memory leaks and ensure smooth execution.

Key Features

✅ No External Dependencies – Uses built-in PowerShell and Word COM automation
✅ UTF-8 Support – Handles international characters correctly
✅ Inline Formatting – Processes bold and italic within any text element
✅ Professional Output – Uses Word’s native styles for consistent formatting
✅ One-Line Execution – Paste and run without saving to a file
✅ Error Handling – Includes try-catch blocks for robust execution
✅ Memory Management – Properly releases COM objects after execution

Use Cases

This script is perfect for:

  • Documentation Automation – Convert markdown documentation to Word format for distribution
  • Report Generation – Transform markdown reports into professional Word documents
  • Content Migration – Batch convert markdown files to Word format
  • Workflow Integration – Incorporate into larger PowerShell automation scripts
  • Quick Conversions – Ad-hoc conversion without installing additional tools

Customization Options

Change Output Location

Modify the $docPath variable to specify a different output location:

$docPath = "C:\Output\CustomName.docx"

Make Word Visible

Set $word.Visible = $true to watch the conversion process in real-time

Adjust Border Styling

Modify the Word constants to customize horizontal rule appearance:

$wdLineWidth150pt = 6  # Change border thickness
$wdColorBlack = 0 # Change border color

Requirements

  • Windows operating system
  • Microsoft Word installed
  • PowerShell 5.1 or later
  • Appropriate permissions to create COM objects

Technical Details

Word COM Constants Used:

  • wdCollapseEnd = 0 – Collapse range to end position
  • wdBorderBottom = 4 – Bottom border identifier
  • wdLineStyleSingle = 1 – Single line style
  • wdColorBlack = 0 – Black color value
  • wdLineWidth150pt = 6 – Border width (1.5pt)

Regex Patterns:

  • Headers: '^(#{1,6})\s+(.+)' – Requires space after #
  • Bullet Lists: '^\s*[-*+]\s+(.+)' – Supports -, *, + markers
  • Numbered Lists: '^\s*\d+\.\s+(.+)' – Matches numbered items
  • Horizontal Rules: '^\s*[-]{3,}\s*$' – Three or more hyphens

Conclusion

This PowerShell one-liner provides a powerful, dependency-free solution for converting Markdown to Word documents. Whether you’re automating documentation workflows or need a quick conversion tool, this script delivers professional results with minimal setup.

Simply update the file path, paste the script, and let PowerShell handle the rest!

Building a Scalable 2D Game Scene Architecture: From Back to Front

Creating a clean, scalable scene architecture for a 2D game is more than just organizing visuals—it’s about building a system that supports gameplay, UI, effects, and camera logic in a way that’s intuitive and future-proof. In this post, we’ll walk through a layered architecture that separates concerns, supports depth-based gameplay, and keeps your UI crisp and your effects polished.

Whether you’re building a vertical shooter, a platformer, or a retro arcade game, this structure gives you the flexibility to scale without chaos.

🧱 Scene Graph Overview

At the core is root_scene, which contains all visual and logical layers. These layers are organized from background to foreground, with clear roles and transformation rules.

root_scene
├── game_group                            # Camera-controlled gameplay container
│   ├── hidden_group                     # Off-screen/inactive entities (object pooling)
│   ├── background_group                 # Default background layer + depth container
│   │   ├── background_bottom_group      # Farthest background visuals (sky, base)
│   │   ├── background_mid_group         # Parallax mid-layers, distant FX
│   │   ├── background_top_group         # Closest background visuals
│   ├── objects_group                    # Default gameplay layer + depth container
│   │   ├── objects_depth_bottom_group   # Farthest gameplay entities
│   │   ├── objects_depth_mid_group      # Primary gameplay layer (player, pickups)
│   │   ├── objects_depth_top_group      # Foreground gameplay entities
│   ├── foreground_group                 # Foreground visuals + depth container
│   │   ├── foreground_bottom_group      # Farthest foreground elements
│   │   ├── foreground_mid_group         # Mid-range foreground visuals
│   │   ├── foreground_top_group         # Closest foreground overlays
│   ├── visual_fx_group                  # Explosions, particles, transient visuals
│
├── hud_group                            # Score, gauges, indicators (screen-anchored)
├── menu_group                           # Title screen, credits (non-blocking UI)
├── modal_group                          # Pause, game over, dialogs (blocking overlays)
├── debug_group                          # Dev-only overlays, performance HUD
├── screen_fx_group                      # CRT shader, bloom, vignette (post-processing)
  

🧠 Layer Roles & Camera Behavior

Each layer has a defined purpose and relationship with the camera. Gameplay and visual layers move with the camera, while UI and post-processing layers remain fixed or apply globally. Note that background and foreground groups can also be used in menu layers along with menu group.

LayerPurposeTransforms with Camera
game_groupMaster container for gameplay layers✅ Yes
hidden_groupObject pooling, inactive/off-screen entities✅ Yes
background_groupDefault background layer✅ Yes
background_bottom_groupFarthest background visuals (sky, base)✅ Yes
background_mid_groupParallax mid-layers, distant FX✅ Yes
background_top_groupClosest background visuals✅ Yes
objects_groupDefault gameplay layer✅ Yes
objects_depth_bottom_groupFarthest gameplay entities✅ Yes
objects_depth_mid_groupCore gameplay layer (player, enemies, pickups)✅ Yes
objects_depth_top_groupForeground gameplay entities✅ Yes
foreground_groupDefault foreground layer✅ Yes
foreground_bottom_groupFarthest foreground visuals✅ Yes
foreground_mid_groupMid-range foreground visuals✅ Yes
foreground_top_groupClosest foreground overlays✅ Yes
visual_fx_groupExplosions, particles, screen shake✅ Yes
hud_groupScore, gauges, indicators❌ No
menu_groupTitle screen, credits❌ No
modal_groupPause, game over, dialogs❌ No
debug_groupDev overlays, performance HUD❌ No
screen_fx_groupPost-processing shaders (CRT, bloom, vignette)❌ No (global)

🧰 API Naming Conventions

To keep things clean and predictable, each layer has dedicated adders and getters. This ensures encapsulation and avoids direct manipulation of scene graph internals.

🔧 Adders

python

add_to_hidden_group(obj)
add_to_background_group(obj)
add_to_background_bottom_group(obj)
add_to_background_mid_group(obj)
add_to_background_top_group(obj)

add_to_objects_group(obj)
add_to_objects_depth_bottom_group(obj)
add_to_objects_depth_mid_group(obj)
add_to_objects_depth_top_group(obj)

add_to_foreground_group(obj)
add_to_foreground_bottom_group(obj)
add_to_foreground_mid_group(obj)
add_to_foreground_top_group(obj)

add_to_visual_fx_group(obj)
add_to_hud_group(obj)
add_to_menu_group(obj)
add_to_modal_group(obj)
add_to_debug_group(obj)
add_to_screen_fx_group(obj)
  

🔍 Getters

python

get_hidden_group()
get_background_group()
get_background_bottom_group()
get_background_mid_group()
get_background_top_group()

get_objects_group()
get_objects_depth_bottom_group()
get_objects_depth_mid_group()
get_objects_depth_top_group()

get_foreground_group()
get_foreground_bottom_group()
get_foreground_mid_group()
get_foreground_top_group()

get_visual_fx_group()
get_hud_group()
get_menu_group()
get_modal_group()
get_debug_group()
get_screen_fx_group()
  

📏 Ownership & Layering Rules

To maintain clarity and prevent misuse, each type of entity has a designated home:

  • Gameplay entitiesobjects_group or one of its depth layers
  • Background visualsbackground_group or its depth layers
  • Foreground visualsforeground_group or its depth layers
  • HUD elementshud_group
  • Menusmenu_group
  • Blocking overlaysmodal_group
  • Debug toolsdebug_group only
  • Visual effectsvisual_fx_group
  • Post-processing shadersscreen_fx_group
  • Camera transformations → applied only to game_group and its children

🚫 Layering Constraints

To avoid rendering chaos and maintain performance:

  • ❌ No toFront() calls in gameplay layers
  • ✅ UI systems may adjust local order within their own group
  • ✅ Depth layers maintain internal z-ordering

✅ Benefits of This Architecture

  • Clear separation of concerns: Each layer has a distinct visual and logical role
  • Scalable and maintainable: Easy to audit, extend, and debug
  • Camera-friendly: game_group isolates gameplay transformations from UI
  • Depth flexibility: objects_group, background_group, and foreground_group support layered interactions
  • UI integrity: HUD and modals remain crisp and unaffected by zoom/shake
  • Post-processing polish: screen_fx_group applies final visual effects globally

🧪 Final Thoughts

This architecture isn’t just a technical blueprint—it’s a philosophy of clarity. By separating gameplay, background, foreground, UI, and effects into well-defined layers, you empower your team to build faster, debug smarter, and scale confidently.

If you’re working on a game and want help adapting this structure to your engine or genre, I’d love to collaborate. Let’s build something beautiful.

How to Fix the GC IPL Error in Dolphin When Using RetroBat

If you’ve ever tried launching a GameCube game through Dolphin and been greeted with the dreaded “GC IPL file could not be found” error, you’re not alone. This issue can be frustrating, especially when everything else seems to be set up correctly. But don’t worry—there’s a simple fix, and we’ll walk you through it.

🧩 What Causes the GC IPL Error?

The error typically stems from a missing or incorrect BIOS file (also known as the IPL file) required for the GameCube boot animation. While the game itself may be perfectly fine, Dolphin attempts to load the BIOS sequence before launching the game—and if it can’t find the right file, it throws an error.

✅ Fixing the Error in Dolphin (Standalone)

If you’re running Dolphin directly (not through RetroBat), you can bypass the BIOS boot sequence entirely by tweaking a simple setting:

  1. Locate your dolphin.ini configuration file.
  2. Open it in a text editor.
  3. Find the line that says SkipIPL.
  4. Set it to True.

ini

[Core]
SkipIPL = True

This tells Dolphin to skip the BIOS animation and jump straight into the game—no IPL file needed.

🔄 Fixing the Error in Dolphin via RetroBat

If you’re using RetroBat as your frontend, the fix is slightly different. RetroBat tends to overwrite Dolphin’s configuration files each time you launch a game, so editing dolphin.ini manually won’t stick.

Instead, you need to configure RetroBat itself to skip the BIOS:

  1. Launch RetroBat and press Start to open the Main Menu.
  2. Navigate to: Game Settings > Per System Advanced Configuration
  3. Select the console you’re working with (e.g., GameCube).
  4. Go to: Emulation > Skip Bios
  5. Set it to Yes.

This ensures that RetroBat tells Dolphin to skip the IPL sequence every time, avoiding the error altogether.

🎮 Final Thoughts

The GC IPL error might seem like a showstopper, but it’s really just a BIOS boot hiccup. Whether you’re using Dolphin standalone or through RetroBat, skipping the IPL sequence is a quick and effective workaround. Now you can get back to what matters—playing your favorite GameCube classics without interruption.

Got other emulation quirks you’re trying to solve? Drop them in the comments or reach out—I’m always up for a good retro tech fix.

Comprehensive Guide to Helping an Ai Coding Agent Identify and Avoid Common Coding Bad Practices

Introduction

In large projects, subtle anti-patterns can slip through reviews—like importing modules mid-file or conditionally. These non-standard import placements obscure dependencies, make static analysis unreliable, and lead to unpredictable runtime errors. This web article dives into that practice, outlines a broader set of coding bad practices, and even provides a ready-to-use AI coding agent prompt to catch every issue across your codebase.

What Is Non-Standard Import Placement?

Imports or require statements buried inside functions, conditional branches, or midway through a file violate expectations of where dependencies live. Best practices and most style guides mandate that:

  • All imports sit at the top of the file, immediately after any module docstring or comments.
  • Conditional or lazy loading only happens with clear justification and documentation.

When imports are scattered:

  1. Static analysis tools can’t reliably determine your project’s dependency graph.
  2. Developers hunting for missing or outdated modules lose time tracing hidden import logic.
  3. You risk circular dependencies, initialization bugs, or runtime surprises.

A Broader List of Coding Bad Practices

Below is a table of widespread anti-patterns—some classic hygiene issues and others that modern AI agents might inject or overlook:

Bad PracticeDescription
Spaghetti CodeCode with no clear structure making maintenance difficult.
Hardcoding ValuesEmbedding constants directly instead of using config or constants.
Magic Numbers/StringsUsing unexplained literals instead of named constants.
Global State AbuseOverusing global variables causing unpredictable side effects.
Poor Naming ConventionsUsing vague or misleading variable and function names.
Lack of ModularityWriting large monolithic blocks instead of reusable functions.
Copy-Paste ProgrammingDuplicating code rather than abstracting shared logic.
No Error HandlingIgnoring exceptions or failing to validate inputs.
OverengineeringAdding unnecessary complexity or abstraction.
Under-documentationFailing to comment or explain non-obvious logic.
Tight CouplingMaking modules overly dependent on each other.
Ignoring Style GuidesNot following language-specific conventions or style guides.
Dead CodeLeaving unused or unreachable code paths in the codebase.
Inconsistent FormattingMixing indentation styles or inconsistent code layout.
Not Using Version Control ProperlyCommitting broken code, poor commit messages, ignoring branching.
Non-standard Import PlacementPlacing imports mid-file or conditionally instead of at the top.
Missing Security ChecksOmitting authentication, authorization, or input sanitization.
Inefficient AlgorithmsUsing suboptimal logic that hurts performance.
Hallucinated DependenciesReferencing non-existent libraries or methods from AI suggestions.
Incomplete Code GenerationLeaving functions or loops unfinished due to AI cutoffs.
Prompt-biased SolutionsGenerating code that only fits the prompt and fails general cases.
Missing Corner CasesOverlooking edge cases and error conditions in logic.
Incorrect Error MessagesProviding vague or misleading error feedback to users.
Logging Sensitive DataWriting confidential information to logs without sanitization.
Violating SOLID PrinciplesBreaking single responsibility or open/closed design rules.
Race ConditionsFailing to handle concurrency leading to unpredictable bugs.

Crafting an AI Coding Agent Prompt

To ensure an AI auditor doesn’t skip files, ignore edge cases, or take shortcuts, use the following prompt. It instructs the agent to comprehensively scan every line, record each finding, and tally occurrences of every bad practice.

## Prompt

You are an expert AI code auditor. Your mission is to exhaustively scan every file and line of the codebase and uncover all instances of known bad practices. Do not skip or shortcut any part of the project, even if the code is large or complex. Report every finding with precise details and clear remediation guidance.

## Scope
- Analyze every source file, configuration, script, and module.
- Treat all code as in-scope; do not assume any file is irrelevant.

## Bad Practices to Detect
- Spaghetti Code
- Hardcoding Values
- Magic Numbers/Strings
- Global State Abuse
- Poor Naming Conventions
- Lack of Modularity
- Copy-Paste Programming
- No Error Handling
- Overengineering
- Under-documentation
- Tight Coupling
- Ignoring Style Guides
- Dead Code
- Inconsistent Formatting
- Improper Version Control Usage
- Non-standard Import Placement
- Missing Security Checks
- Inefficient Algorithms
- Hallucinated Dependencies
- Incomplete Code Generation
- Prompt-biased Solutions
- Missing Corner Cases
- Incorrect Error Messages
- Logging Sensitive Data
- Violating SOLID Principles
- Race Conditions

## Analysis Instructions
1. Traverse the entire directory tree and open every file.
2. Inspect every line—do not skip blank or comment lines.
3. Identify code snippets matching any bad practice.
4. For each instance, document:
   - File path
   - Line number(s)
   - Exact snippet
   - Bad practice name
   - Explanation of why it’s problematic
   - Suggested refactoring

5. Keep a running tally of occurrences per bad practice.

## Output Requirements
- Use Markdown with a section per file.
- Subheadings for each issue.
- End with a summary table listing each bad practice and its total count.
- If the repo is too large, process in ordered batches (e.g., by folder), confirming coverage before proceeding.
- Do not conclude until every file has been reviewed.

Begin the full project audit now, acknowledging you will not take shortcuts.

Next Steps

  • Integrate this prompt into your AI workflow or CI pipeline.
  • Pair it with linters and static analyzers (ESLint, Flake8, Prettier) for automated, real-time checks.
  • Enforce code review policies that catch both human and AI-introduced anti-patterns.

By combining clear style guidelines, automated linting, and an uncompromising AI audit prompt, you’ll dramatically improve code quality, maintainability, and security—project-wide.

Fixing Emulators in RetroBat: Quick Install Guide

Sometimes, quite often actually 🙄, things get corrupted in RetroBat. I’m not knocking it, it’s an absolutelly fantastic emulation frontend and thinkering is just part of the retro games emulation experience. But, yeah, with thinkering. unfortunately things get broke. This includes the emulators themselves.

A quick and dirty way of performing a fresh install of an emulator in RetroBat is to simply delete the specific emulator folder. For example to remove Duckstation, navigate to RetroBat\emulators and then delete Duckstation. To reinstall it then simply open RetroBat enter RETROBAT emulator list and then reinstall.

Side Note:

Instead of Duckstation you can also use Swanstation in Retroarch.

A description of the two is below:

🦆 DuckStation

  • Type: Standalone emulator
  • Focus: High compatibility, speed, and long-term maintainability
  • Platform: Available on Windows, Linux, Android, and macOS
  • Features:
    • Modern UI
    • Save states, widescreen hacks, texture filtering
    • Supports achievements (RetroAchievements)
  • Development: Actively maintained by its original developer
  • Best For: Users who want a full-featured, standalone PS1 emulator with a modern interface

🦢 SwanStation

  • Type: Libretro core (used within RetroArch)
  • Origin: Fork of DuckStation, created due to licensing and distribution disagreements
  • Focus: Same as DuckStation—playability and performance—but within the RetroArch ecosystem
  • Features:
    • Nearly identical emulation to DuckStation
    • Integrated into RetroArch’s unified interface
  • Limitations:
    • May lag behind DuckStation in updates
    • Slightly less customizable outside of RetroArch
  • Best For: Users who prefer RetroArch’s all-in-one emulator interface

How to fix a noisy GPU fan

If you have an old GPU and you have noticed it is creating more noise now than when it was first installed, it may be because the bearing is no longer sufficiently lubricated.

A new fan off EBay, or new to you, might not be a sound investment. This is true assuming you can even find a replacement. Luckily most GPU fans can be serviced.

To Lubricate the Fan Bearing:

Remove the GPU from your computer.

Spin the fan manually. If it is not mostly silent, then there is a problem with the bearing. More than likely, there is just insufficient lubricant.

Carefully peel back the sticker on the top of the fan to expose the bearing. If access to the bearing is not provided on the top of the fan, then remove the fan from the GPU housing. Peel back the sticker on the back of the fan. If you see a yellowish mark on the inside of the sticker where the bearing is, this confirms the lubricant has leaked somewhat. If access to the bearing is not provided at the bottom of the fan either then very carefully try to remove the blade.

Once the bearing is exposed apply a small drop of light machine oil or sewing machine oil to the bearing. Singer oil is a good choice.

Rotate the fan manually to work the oil into the bearing.

Replace the sticker or use a small piece of tape to cover the bearing.

Before reinstalling the GPU, you might consider also applying fresh thermal paste to the GPU processor. This will help keep temperatures down, giving the fan less work to do.

How to fix no audio issues with RetroArch on Windows 10 or 11

To troubleshoot a sound issue with RetroArch, follow these steps:

  1. Check that DirectX 9 is installed on the PC. DirectX 9 is not part of Windows 11 by default and if you are running retroarch via an external drive, i.e. usb key, on a new machine it may not have the necessary runtime installed. It can be downloaded here: LINK Note: when the installer is run it will ask what folder to use. This folder is just a temp folder, essentially it is asking where the contents should be extracted. Once the process is finised navigate to the folder you chose and run the DXSETUP.exe file. Once this file has run you can delete the temp folder.
  2. Check if the RetroArch program is muted by pressing random keys on your computer. If it’s muted, go to Settings > Audio and turn off Mute.
  3. If the sound issue persists, try setting the default audio driver to Wasapi and unchecking WASAPI Exclusive Mode and WASAPI Float Format.
  4. If the volume mixer is the culprit, check if it’s listed on the volume mixer and check if RetroArch was set to low volume or muted. If it’s not listed, try downloading a new copy of RetroArch from their website and extracting it into a new directory.
  5. Restart after trying the solutions above.

Organizing ROM Files: How to Safely Move and Sort by Region

Typically there is a pattern to rom file names indicating what region the files belong to. For example it might explicitly state “(USA)” in the file name. However this alone cannot be taken as confirmation that “USA” means the game is from the USA region, USA could simply be part of the game title, e.g. “Daytona USA” etc. Japanese roms often end with the letter “j” but again this could just be part of the name of the game.

So how can one go about cleaning a rom folder without destroying these roms in the process?

You can still use these string elements to move files from one folder to another. The code below will not delete the files it will just move them en masse. If you have found a game was wrongly moved you can always return it.

Note: Always backup files and folders before you manipulate them programmatically.

The code below will need to be updated to reference your specific rom folder and where you want the files to move as well as the character string you are targeting i.e. *j.zip

@echo off

REM Examples file types:
REM Move Japanese files target is *j.zip
REM Move USA files target is *u.zip
REM Move USA files target is *(USA).zip
set target="*j.zip"

set source_folder="C:\roms\"
set destination_folder="C:\roms\_j_roms"

if not exist %destination_folder% (
    md %destination_folder%
)

move %source_folder%%target% %destination_folder%

echo Files with the extension %target% have been moved to %destination_folder%

How to Secure Your Azure SQL Database

  1. Authentication and Authorization:
    • Use Azure Active Directory (Azure AD) authentication for better security.
    • Implement firewall rules to control access to your database.
    • Assign minimal permissions to users based on their roles (principle of least privilege).
  2. Encryption:
    • Enable Transparent Data Encryption (TDE) to protect data at rest.
    • Use Always Encrypted to secure sensitive data in transit.
    • Consider client-side encryption for additional protection.
  3. Auditing and Monitoring:
    • Enable Azure SQL Auditing to track database activity.
    • Set up Azure Monitor to receive alerts and insights.
    • Regularly review logs and audit trails.
  4. Network Security:
    • Isolate your database using Virtual Network Service Endpoints.
    • Restrict public access and use private endpoints.
  5. Patch Management:
    • Keep your database engine up to date with the latest security patches.
    • Regularly review vulnerability assessments.
  6. Backup and Recovery:
    • Implement automated backups and test recovery procedures (remember a backup is only theoretically there unless it has been tested and proven to work).
    • Store backups conforming to the 3-2-1 Backup Rule explained below (do not assume your backups are safe just because they are in the cloud).

The 3-2-1 Backup Rule: Ensuring Data Resilience

The 3-2-1 Rule is a robust strategy that emphasizes redundancy, resilience, and data availability. Here’s what it entails:

  1. Three Copies of Your Data:
    • Maintain the original data and create at least two additional copies.
  2. Two Different Types of Media for Storage:
    • Store your data on distinct forms of media (e.g., hard drives, tapes) to enhance redundancy.
  3. At Least One Copy Off-Site:
    • Safeguard one backup copy in an off-site location, separate from your primary data and on-site backups.

By adhering to this rule, you mitigate single points of failure, protect against corruption, and ensure data safety even in unexpected events or disasters

How to get PICO-8 games to run on Retroid Pocket using Retroarch

One of the best ways to play PICO-8 games on a Retroid Pocket is via the Retroarch core retro8.

However you may run into the problem of only PICO-8 cart images being displayed rather than Retroarch launching the actual game.

You can solve this problem by doing the following:

Retroarch Settings > User Interface > File Browser > Use Built-In Image Viewer and set it on “No”. This way the image viewer will not get in the way, misinterpreting a PICO-8 cart as just a png file.

Happy Gaming!