Streamlining Your Stable Diffusion Extensions update with a Handy PowerShell Script in terminal

When dealing with multiple git repositories in subdirectory. going to each one and making a git pull requires time and can be tedious. Software like stable diffusion the generative image AI with its multiple extensions. although you can update them inside the gui. updating the extensions through terminal is smooth and easy to manage if you have a script.  That’s where pullall.ps1, a PowerShell script, comes into play. This script is a lifesaver for enthusiasts working with multiple Git repositories, particularly those related to Stable Diffusion extensions. Let’s dive deeper into how this script can enhance your workflow.

The Role of Git and GitHub in Managing Stable Diffusion Extensions
Before we get into the script, let’s understand the context. Stable Diffusion, like many other software projects, often requires the installation of multiple extensions. These extensions are frequently hosted on GitHub and managed using Git, a distributed version control system. Each extension is typically in its own Git repository. This setup ensures that the core software remains stable while allowing users to experiment with and contribute to various extensions.

The Challenge of Managing Multiple Repositories
Managing several Git repositories can be cumbersome, especially if you’re trying to keep all your extensions up to date. Traditionally, you’d have to navigate to each repository’s directory and run git pull manually. This is time-consuming and prone to human error.

Solution: The pullall.ps1 Script:

Create a file called pullall.ps1 in the directory where extensions stored. then you can run it in powershell as .\pullall.ps1

# This script finds all Git repositories in the current directory and its subdirectories, and runs `git pull` in each one.

Get-ChildItem -Recurse | Where-Object { $_.PSIsContainer -and (Test-Path "$($_.FullName)\.git") } | ForEach-Object { Set-Location $_.FullName; git pull }

The pullall.ps1 script presents an elegant solution to this problem. Written in PowerShell, a powerful scripting language for automating the Windows environment, this script automates the process of updating all your Git repositories in one go. It’s especially useful for developers and tech enthusiasts who work with multiple extensions of Stable Diffusion.

How the Script Works
Finding Repositories: The script starts by using the Get-ChildItem -Recurse command, which searches for items in the current directory and its subdirectories.

Filtering for Git Repositories: It then filters these items using Where-Object. This part of the script checks two conditions: whether the item is a directory ($_.PSIsContainer) and whether this directory contains a .git folder (indicating it’s a Git repository).

Updating Each Repository: Finally, for each Git repository found, the script changes the current location to that repository’s directory (Set-Location $_.FullName) and executes git pull. This command updates the local repository with the latest changes from its remote counterpart.

Applications Beyond Stable Diffusion
While particularly beneficial for managing Stable Diffusion extensions, pullall.ps1 is not limited to this use case. It’s a versatile tool that can be used in any scenario where you have multiple Git repositories. Whether you’re a web developer managing various project modules or a data scientist working with different data sets, this script can save you a significant amount of time and effort.

In the rapidly evolving world of software development, tools that save time and reduce repetitive tasks are invaluable. The pullall.ps1 script is a perfect example of such a tool. It exemplifies how a simple automation script can have a substantial impact on your workflow, allowing you to focus on more creative and challenging aspects of your projects.

For Stable Diffusion enthusiasts and developers managing multiple Git repositories, incorporating this script into your routine can streamline your update process, ensuring that you’re always working with the latest and greatest extensions without the hassle of manual updates. Happy coding! 🚀

C++ cool cheetsheet produced by ChatGPT to refresh your memory

chatGPT is really helpful tool to programmers. these cheetsheet were produced by chatGPT 3.5 to help refresh your memory. if you are advanced programmer or have background in other languages. it can help to look at simple one liners instead of going through long pages of documentations

Keep in mind, chatGPT sometimes produces inaccurate information and sometimes it hallucinates:

  • Declaration of variables: int a = 10;
  • Conditional statements: if (a == 10) { ... } else { ... }
  • Loops: for (int i = 0; i < 10; i++) { ... } or while (condition) { ... }
  • Functions: void myFunction(int arg1, double arg2) { ... }
  • Classes and objects: class MyClass { ... }; MyClass myObject;
  • Inheritance: class ChildClass : public ParentClass { ... }
  • Polymorphism: virtual void myFunction() { ... } and override keyword in child classes
  • Templates: template void myFunction(T arg) { ... }
  • Standard libraries: #include for input/output, #include for dynamic arrays, #include for string manipulation, and many others.
  • Pointers and references: int *ptr = &a; and int &ref = a;
  • Memory management: new and delete for dynamic memory allocation and deallocation
  • Exception handling: try { ... } catch (exceptionType e) { ... }
  • Namespaces: namespace myNamespace { ... }
  • Macros: #define MY_MACRO(value) (value * 2)
  • Preprocessor directives: #include for header files, #ifdef and #ifndef for conditional compilation
  • Operator overloading: operator+, operator-, etc. can be overloaded for custom classes
  • Type casting: static_cast, dynamic_cast, reinterpret_cast, and const_cast
  • Standard Template Library (STL): provides containers like vector, map, set, and algorithms like sort, find, and accumulate
  • File input/output: fstream for reading/writing to files
  • String streams: stringstream for parsing and formatting strings
  • Multi-threading: std::thread for creating threads, std::mutex for thread synchronization
  • Function objects: std::function for storing and invoking callable objects
  • Lambda expressions: [] (int a, int b) { return a + b; } for inline functions or function objects
  • Range-based for loop: for (auto x : myVector) { ... } for iterating over a range of values
  • Smart pointers: std::unique_ptr and std::shared_ptr for automatic memory management
  • Regular expressions: std::regex for pattern matching and search in strings
  • Type traits: std::is_integral, std::is_floating_point, and others for compile-time type analysis
  • Move semantics: std::move for efficient transfer of ownership of objects
  • Variadic templates: template void myFunction(Args... args) { ... } for functions that can take any number of arguments.
  • Type deduction: auto for automatic type deduction of variables and lambda expressions
  • Rvalue references: int &&rref = 42; for binding to temporaries and move semantics
  • User-defined literals: 42_milliseconds or 3.14_pi for custom literals of user-defined types
  • Initialization lists: {1, 2, 3} for initializing objects and containers
  • Uniform initialization: MyClass obj{1, "hello"}; for consistent initialization syntax
  • constexpr functions: constexpr int factorial(int n) { ... } for compile-time evaluation of functions
  • Type aliases: using myInt = int; for creating aliases for types or templates
  • Concepts: template concept MyConcept = ... for expressing requirements on template arguments
  • Modules: import myModule; for modularization of code and faster compilation
  • Co-routines: co_await and co_yield for implementing asynchronous code and generators.
  • esign patterns: C++ supports many design patterns such as the Singleton pattern, the Observer pattern, and the Factory pattern.
  • Multiple inheritance: C++ allows classes to inherit from multiple base classes, providing flexibility in class hierarchy design.
  • C++11 features: C++11 introduced new language features such as lambdas, range-based for loops, and smart pointers to improve expressiveness and safety of C++ code.
  • C++14 features: C++14 added new features such as binary literals, generic lambdas, and extended constexpr to further improve the language.
  • C++17 features: C++17 added new features such as structured bindings, constexpr if, and fold expressions to provide more powerful and expressive templates.
  • C++20 features: C++20 introduced new features such as concepts, coroutines, and modules to further improve the language.
  • Third-party libraries: C++ has a vast ecosystem of third-party libraries such as Boost, Eigen, and OpenCV that provide additional functionality for C++ developers.
  • IDEs: Integrated development environments (IDEs) such as Visual Studio, CLion, and Code::Blocks provide powerful tools for editing, debugging, and testing C++ code.
  • Here are some briefs about common C++ headers, Qt headers, controls, and external libraries:C++ headers:
    • : Input/output library for C++.
    • : STL container for dynamic arrays.
    • : STL container for strings.
    • : Input/output library for files.
    • : STL algorithms for containers.

    Qt headers:

    • : Main application class for Qt Widgets.
    • : Main application class for Qt Quick.
    • : Base class for all Qt Widgets.
    • : Base class for all Qt Quick items.
    • : Base class for all Qt Widgets layouts.
    • : Class for creating QML objects dynamically.

    Common Qt controls:

    • QLabel: Control for displaying text and images.
    • QLineEdit: Control for editing text.
    • QPushButton: Control for triggering actions.
    • QCheckBox: Control for toggling on/off states.
    • QRadioButton: Control for selecting a single option from a set.
    • QComboBox: Control for selecting one option from a drop-down list.
    • QSpinBox: Control for selecting a numeric value from a range.
    • QSlider: Control for selecting a numeric value from a range with a slider.
    • QTableView: Control for displaying data in a table format.

    External libraries:

    • Boost: Collection of libraries for C++, including support for smart pointers, regular expressions, and numerical algorithms.
    • OpenCV: Library for computer vision and image processing.
    • Eigen: Library for linear algebra.
    • Qt Charts: Library for creating charts and graphs in Qt applications.
    • Qt WebEngine: Library for embedding web content into Qt applications.
    • Qt Network: Library for network programming in Qt applications.
    • Qt Multimedia: Library for audio and video playback and recording in Qt applications.

Introducing thymeleaf-i18n-helper: A New i18n Messages Helper for Spring Boot Thymeleaf

If you’re working with Spring Boot Thymeleaf message, you know that managing i18n messages can be a challenge. That’s why we’re excited to introduce our new thymeleaf-i18n-helper extension for Visual Studio Code.


Our extension makes it easy to convert text on selection to #{message} and adds it to your message properties file. It will even prompt you for variable name with default value and file. Additionally, you can switch between available languages based on properties file with selection in the status bar.

The thymeleaf-i18n-helper extension is currently in pre-release, so we encourage you to try it out and report any bugs you encounter. We’re confident that with your feedback, we can make this extension even better and more useful for developers working with Spring Boot Thymeleaf.


  • Convert text on selection to #{message} and adds it to message properties file
  • Prompts user for variable name with default value and file
  • Switch between available languages based on properties file with selection in status bar
  • Detect if text already exists or if variable already exists
  • Create th:text if it detects it’s only text within the tag
  • Creates a span with remove tag otherwise

Check out our GitHub repository for more information and to download the extension.

Marketplace: Vscode marketplace


  • Spring Boot with Thymeleaf and properties files
  • Tested on Boot 3

Extension Settings

  • thymeleaf-i18n-helper.exclude: (Optional) Exclude files
  • thymeleaf-i18n-helper.folder: (Optional) Specify i18n path to restrict search in those files

Thank you for trying out thymeleaf-i18n-helper! We look forward to hearing your feedback and making this extension even better.

Quasar excellent VUE framework to speed up development and streamline web app development

Quasar is a framework that is built on top of Vue.js, which is a progressive JavaScript framework used for building user interfaces. Quasar is an open-source framework that provides developers with a comprehensive set of tools and components to build high-quality web applications.

One of the main benefits of Quasar is its ease of use. It is designed to make the development process faster and more efficient, with pre-built components and a ready-to-use UI kit that allows developers to focus on their application logic rather than the layout and styling. The framework provides a clean and intuitive API that simplifies the development process, making it easier for developers to create responsive web applications quickly.

Quasar also provides a range of useful features that can help developers to create modern web applications with ease. For instance, it comes with a built-in icon set, color picker, and image selector, which saves time for developers by removing the need to search and find third-party libraries. The framework also has a robust build system that makes it easy to compile and package the application for deployment.

Another benefit of using Quasar is its comprehensive set of components. The framework comes with a large number of reusable components that can be easily integrated into the application. These components include various UI elements such as buttons, forms, and menus, as well as more advanced components like carousels, modals, and dialogs. With these pre-built components, developers can create beautiful and functional applications in a shorter time frame.

Quasar also offers excellent cross-platform support. Developers can use the framework to build web applications that work well on desktop and mobile devices, as well as native applications for iOS and Android. This makes Quasar an excellent choice for building modern applications that need to work on a wide range of devices.

Finally, Quasar has an active and supportive community of developers. This means that developers can easily find help and support when needed. The community offers a range of resources such as tutorials, forums, and documentation, which makes it easy for developers to get started with the framework.

In conclusion, Quasar is an excellent framework that offers many benefits for developers. Its ease of use, comprehensive set of components, and cross-platform support make it an excellent choice for building modern web applications. Additionally, its active and supportive community makes it a great choice for developers who want to get up to speed quickly and build high-quality applications with ease.


Install Node.js if it is not already installed. You can download it from the official website:

Open a command prompt or terminal window and install Quasar CLI by running the following command:

npm install -g @quasar/cli

Create a new Quasar project by running the following command:

quasar create my-project

This command will create a new Quasar project in a directory named “my-project”.

Navigate to the newly created directory:

cd my-project

Start the development server by running the following command:

quasar dev

Open your web browser and go to the following URL:


You should see the default Quasar welcome page.

Create a new page by running the following command:

quasar new page hello

This will create a new page named “Hello” in the “src/pages” directory.

Edit the newly created file “src/pages/Hello.vue” and replace its content with the following code:

    <h1>Hello, world!</h1>

Save the file.

Restart the development server by stopping the previous “quasar dev” command and running it again.

Open your web browser and go to the following URL:


You should see the “Hello, world!” message displayed on the page.

Congratulations, you have successfully installed Quasar and created a “Hello, world!” sample page!

Corrupt directory causes windows issues and hanging

Windows 10 is a popular and reliable operating system, but it can sometimes encounter issues that make it difficult to use. If you’re experiencing problems like Windows Defender hanging in quick scan, your PC not restarting, or weird things happening on your computer, you’re not alone. In this article, we’ll take a look at some of the most common Windows 10 problems and how to solve them.

One common issue that many Windows 10 users face is that their PC hangs almost daily. When this happens, the taskbar may stop responding, new applications won’t start, and the Ctrl-Alt-Del function doesn’t work. Eventually, everything may stop, including the desktop. Because this problem doesn’t happen every time, it can be difficult to determine the cause.

Some users assume that the problem may be due to hardware issues and will try removing and replacing parts or replacing hard disk cables. However, this often doesn’t solve the problem.

If you’re experiencing these issues, it may be time to consider other possible causes. For example, you may have inherited some old programs from previous versions of Windows that are no longer compatible with Windows 10. One common example is Nero 7 Essentials, which may no longer work properly on your system. It’s also possible that some of the default Windows features may be causing the problem. For instance, some features that are enabled or disabled by default may need to be changed.

However, one other rare cause of these issues may be a corrupt directory like Cygwin for me that has been kept on the C drive. If the directory name has turned into some wrongly encoded character, it may be impossible to delete it from Windows Explorer. This can cause some Windows services like search indexer and Windows Defender scheduled scan to hang, which can then cause Windows to hang.

To solve these issues, it’s important to uninstall any old programs that may be causing compatibility issues. You can also check the default Windows features that are enabled and disabled and make sure that they are appropriate for your system. Finally, you should check for any corrupt directories on your system and take steps to delete them if necessary.

By following these steps, you can solve some of common Windows 10 problems and ensure that your system is running smoothly and efficiently.