DEV Community: vast cow

How to Separate CUDA-Specific Code from Regular C++ Code

vast cow — Thu, 16 Jul 2026 11:06:32 +0000

In a CUDA application, you can place GPU kernels and device memory-related code in .cu files while keeping ordinary C++ logic in .cpp files.

This structure helps prevent CUDA-specific code from being mixed with application logic, making each part of the codebase easier to understand and maintain.

File Organization

A typical separation of responsibilities looks like this:

cuda.cu
- CUDA kernels
- __constant__ memory
- CUDA-specific functions
host.cpp
- main function
- Input/output
- Memory allocation
- Kernel launches
- Result verification

CUDA-Side Implementation

On the CUDA side, define the constant memory and the kernel.

// cuda.cu

#include <cstdint>

// Constant memory with one element
__constant__ std::uint32_t constant_value[1];

// Kernel that copies the constant memory value to global memory
__global__ void copyConstantToGlobal(std::uint32_t* destination)
{
    if (blockIdx.x == 0 && threadIdx.x == 0) {
        destination[0] = constant_value[0];
    }
}

constant_value stores the value that will be accessed from the GPU.

The copyConstantToGlobal kernel copies the value stored in constant memory into global memory.

Referencing CUDA Symbols from C++

A standard C++ compiler cannot process CUDA-specific keywords such as __constant__ and __global__.

Therefore, declare these symbols in the C++ source without CUDA qualifiers.

// host.cpp

#include <cstdint>

extern std::uint32_t constant_value[1];

void copyConstantToGlobal(std::uint32_t* destination);

These are declarations, not definitions. They simply reference symbols that are defined in another translation unit.

Writing a Value to Constant Memory

To write a value from the host to constant memory, first obtain the device address with cudaGetSymbolAddress.

void* constant_address = nullptr;

CUDA_CHECK(cudaGetSymbolAddress(
    &constant_address,
    constant_value
));

Then copy the value to that address using cudaMemcpy.

CUDA_CHECK(cudaMemcpy(
    constant_address,
    &input_value,
    sizeof(input_value),
    cudaMemcpyHostToDevice
));

This stores the host-generated value in constant_value[0].

Allocating Global Memory for Output

Allocate global memory on the GPU to hold the kernel output.

std::uint32_t* device_output = nullptr;

CUDA_CHECK(cudaMalloc(
    reinterpret_cast<void**>(&device_output),
    sizeof(*device_output)
));

This allocates enough space for a single std::uint32_t.

Launching the Kernel with `cudaLaunchKernel`

Normally, a kernel is launched inside a .cu file using the following syntax:

copyConstantToGlobal<<<1, 1>>>(device_output);

However, the <<<...>>> launch syntax is not supported by a standard C++ compiler.

When launching a kernel from a .cpp file, use cudaLaunchKernel instead.

Preparing the Kernel Arguments

cudaLaunchKernel expects an array containing the addresses of host variables that hold the kernel arguments.

In this example, the kernel has a single argument:

std::uint32_t* destination

Since device_output is the pointer value to be passed to the kernel, register the address of that variable, &device_output.

void* kernel_args[] = {
    &device_output
};

Launching the Kernel

const dim3 grid_dim(1, 1, 1);
const dim3 block_dim(1, 1, 1);

CUDA_CHECK(cudaLaunchKernel(
    reinterpret_cast<const void*>(copyConstantToGlobal),
    grid_dim,
    block_dim,
    kernel_args,
    0,
    nullptr
));

The arguments are as follows:

copyConstantToGlobal
- The kernel to launch.
grid_dim
- Grid dimensions.
block_dim
- Block dimensions.
kernel_args
- Kernel arguments.
0
- Size of dynamically allocated shared memory.
nullptr
- Use the default stream.

Since this example copies only a single value, the kernel is launched with one block containing one thread.

Waiting for Kernel Completion

After launching the kernel, check for launch errors and wait for execution to complete.

CUDA_CHECK(cudaGetLastError());
CUDA_CHECK(cudaDeviceSynchronize());

Kernel launches through cudaLaunchKernel are asynchronous. Before reading back the result, call cudaDeviceSynchronize to ensure the GPU has finished execution.

Copying the Result Back to the Host

Copy the output value from GPU memory back to the host.

std::uint32_t output_value = 0;

CUDA_CHECK(cudaMemcpy(
    &output_value,
    device_output,
    sizeof(output_value),
    cudaMemcpyDeviceToHost
));

You can verify correct operation by comparing the written value with the value read back.

const bool succeeded = input_value == output_value;

std::cout << "Result        : "
          << (succeeded ? "PASS" : "FAIL")
          << std::endl;

Finally, release the allocated GPU memory.

CUDA_CHECK(cudaFree(device_output));

Compiling

Compile CUDA source files with nvcc and regular C++ source files with g++.

nvcc -rdc=true -c cuda.cu
g++ -c host.cpp
nvcc cuda.o host.o -o constant_symbol_test

It is important to perform the final linking step with nvcc. Using nvcc ensures that the CUDA runtime and device code are linked correctly.

The -rdc=true option enables separate compilation of CUDA code across multiple translation units.

Purpose of This Structure

Separating CUDA code from standard C++ code provides several benefits:

Clearly separates GPU processing from host-side logic.
Allows .cpp files to be compiled with a standard C++ compiler.
Prevents CUDA-specific syntax from spreading throughout the application.
Makes the CUDA implementation easier to manage as an independent module.
Simplifies integrating CUDA into an existing C++ project.

The key idea is to place CUDA-specific definitions in .cu files while declaring only the required symbols in standard C++ form on the host side.

Instead of using the <<<...>>> launch syntax, launch kernels from .cpp files with cudaLaunchKernel, and perform the final linking step with nvcc.

How to Automatically Switch Google Translate to Dark Theme

vast cow — Wed, 15 Jul 2026 12:18:40 +0000

If you use Google Translate for long periods, the bright interface can become uncomfortable to look at. A convenient solution is a user script that automatically switches Google Translate to a dark theme based on your computer's or browser's appearance settings.

Once installed, the script changes the background, input fields, translation results, menus, and other interface elements to a dark color scheme whenever your device is in dark mode. When you switch back to light mode, Google Translate automatically returns to its normal appearance.

Main Purpose

The purpose of this script is to make Google Translate easier to view by applying a dark color scheme.

It is especially useful when using Google Translate at night or in dimly lit environments, as it reduces screen glare. Because it follows your operating system's or browser's theme settings, you don't need to switch themes manually each time.

Requirements

To use this script, you need a browser extension that supports user scripts.

Popular options include Tampermonkey and Violentmonkey. These extensions are available for browsers such as Chrome, Edge, and Firefox.

Installation

1. Install a User Script Extension

Install either Tampermonkey or Violentmonkey in your browser.

2. Create a New Script

Open the extension's dashboard and select an option such as Create a New Script.

3. Paste the Script

Delete the default template and paste the automatic dark theme script for Google Translate.

4. Save the Script

Save the script and make sure it is enabled.

5. Open Google Translate

Open the Google Translate website. If it is already open, refresh the page.

How to Use

No additional setup is required after installation.

When your computer or browser is in dark mode, Google Translate automatically switches to a dark appearance. When you switch back to light mode, Google Translate returns to its standard light theme.

The script adjusts the following interface elements:

The page background
Translation input fields
Translation result area
Language selection menus
Buttons and tabs
Pop-up menus
Scrollbars

The script also detects newly added elements within the Google Translate interface, helping maintain the dark theme even after interacting with the page.

Notes

If Google updates the layout or structure of the Google Translate website, some elements may no longer be styled correctly. In such cases, the script may need to be updated.

In addition, using other Google Translate user scripts or appearance-modifying extensions at the same time may cause display issues.

If you encounter problems, temporarily disable other theme-related extensions or scripts to see if they are causing the conflict.

Summary

The automatic dark theme script for Google Translate lets the site's appearance follow your operating system's or browser's theme settings automatically.

Once installed, there's no need to adjust the theme manually, making Google Translate more comfortable to use, especially during nighttime or in low-light environments.

// ==UserScript==
// @name         Google Translate Auto Dark Theme
// @namespace    https://translate.google.com/
// @version      3.0.0
// @description  Follows prefers-color-scheme. Uses the default theme in light mode and applies a custom theme in dark mode.
// @match        https://translate.google.com/*
// @match        https://translate.google.co.jp/*
// @grant        GM_addStyle
// @run-at       document-start
// ==/UserScript==

(() => {
    'use strict';

    const STYLE_ID = 'tm-google-translate-auto-theme-v3';

    const css = String.raw`
        /*
         * Apply the custom theme only when the OS or browser
         * is in dark mode.
         *
         * In light mode, no styles are overridden, so
         * Google Translate's default theme remains unchanged.
         */
        @media (prefers-color-scheme: dark) {
            :root {
                color-scheme: dark !important;

                --tm-page: #0f1115;
                --tm-surface: #171a20;
                --tm-surface-2: #1d222b;
                --tm-surface-blue: #1d2735;
                --tm-hover: #282e38;
                --tm-border: #3b424d;
                --tm-text: #e8eaed;
                --tm-text-2: #bdc1c6;
                --tm-muted: #9aa0a6;
                --tm-accent: #8ab4f8;
                --tm-selection: #3d5f91;
                --tm-scrollbar: #565e69;
                --tm-scrollbar-hover: #707985;

                /*
                 * Google Material Design color variables.
                 */
                --gm3-sys-color-surface: var(--tm-surface) !important;
                --gm3-sys-color-surface-container: var(--tm-surface-2) !important;
                --gm3-sys-color-surface-container-low: var(--tm-surface) !important;
                --gm3-sys-color-surface-container-lowest: var(--tm-page) !important;
                --gm3-sys-color-surface-container-high: var(--tm-surface-2) !important;
                --gm3-sys-color-surface-container-highest: var(--tm-hover) !important;
                --gm3-sys-color-surface-variant: var(--tm-border) !important;
                --gm3-sys-color-on-surface: var(--tm-text) !important;
                --gm3-sys-color-on-surface-variant: var(--tm-text-2) !important;
                --gm3-sys-color-outline: var(--tm-border) !important;
                --gm3-sys-color-outline-variant: var(--tm-border) !important;
            }

            html,
            body,
            #yDmH0d {
                background-color: var(--tm-page) !important;
                color: var(--tm-text) !important;
            }

            /*
             * Primary containers that often remain white.
             */
            .ccvoYb,
            .gb_fd,
            .gb_cd,
            .gb_jd {
                background-color: var(--tm-surface) !important;
                border-color: var(--tm-border) !important;
            }

            /*
             * Pale blue translation result panel.
             */
            .QcsUad,
            .QcsUad.sMVRZe,
            .QcsUad.hCXDsb,
            .QcsUad.wneUed {
                background-color: var(--tm-surface-blue) !important;
                color: var(--tm-text) !important;
            }

            /*
             * Rounded buttons such as History and Saved.
             */
            .ySES5 {
                background-color: var(--tm-surface-2) !important;
                color: var(--tm-accent) !important;
                border-color: var(--tm-border) !important;
            }

            /*
             * White gradient at the right end of the language tabs.
             */
            .X4DQ0::after {
                background: linear-gradient(
                    to right,
                    rgba(23, 26, 32, 0),
                    var(--tm-surface)
                ) !important;
            }

            /*
             * Similar pseudo-elements used in horizontal scroll areas.
             */
            [class*="X4DQ0"]::after {
                background-image: linear-gradient(
                    to right,
                    rgba(23, 26, 32, 0),
                    var(--tm-surface)
                ) !important;
            }

            header,
            nav,
            footer,
            main,
            [role="banner"],
            [role="navigation"] {
                border-color: var(--tm-border) !important;
            }

            textarea,
            input,
            select,
            [role="textbox"],
            [contenteditable="true"] {
                background-color: transparent !important;
                color: var(--tm-text) !important;
                caret-color: var(--tm-accent) !important;
                border-color: var(--tm-border) !important;
            }

            textarea::placeholder,
            input::placeholder {
                color: var(--tm-muted) !important;
                opacity: 1 !important;
            }

            button,
            [role="button"],
            [role="tab"],
            [role="option"] {
                border-color: var(--tm-border) !important;
            }

            button:hover,
            [role="button"]:hover,
            [role="tab"]:hover,
            [role="option"]:hover {
                background-color: var(--tm-hover) !important;
            }

            [role="tab"][aria-selected="true"],
            [aria-checked="true"],
            [aria-current="true"] {
                color: var(--tm-accent) !important;
            }

            [role="dialog"],
            [role="menu"],
            [role="listbox"],
            [role="tooltip"],
            [aria-modal="true"],
            .goog-menu,
            .goog-menuitem,
            .goog-tooltip,
            .ita-kd-menu,
            .ita-kd-dropdown-menu,
            .ita-kd-statusbar {
                background-color: var(--tm-surface-2) !important;
                color: var(--tm-text) !important;
                border-color: var(--tm-border) !important;
                box-shadow: 0 6px 18px rgba(0, 0, 0, 0.55) !important;
            }

            [role="option"][aria-selected="true"],
            .goog-menuitem-highlight,
            .goog-menuitem:hover,
            .ita-kd-menuitem:hover {
                background-color: var(--tm-hover) !important;
            }

            hr,
            [role="separator"] {
                background-color: var(--tm-border) !important;
                border-color: var(--tm-border) !important;
            }

            a,
            a:visited {
                color: var(--tm-accent) !important;
            }

            /*
             * Bright backgrounds detected by JavaScript.
             */
            .tm-gt-auto-bg {
                background-color: var(--tm-surface) !important;
                border-color: var(--tm-border) !important;
            }

            .tm-gt-auto-bg-blue {
                background-color: var(--tm-surface-blue) !important;
                border-color: var(--tm-border) !important;
            }

            /*
             * Bright gradients detected by JavaScript.
             */
            .tm-gt-auto-gradient {
                background-image: linear-gradient(
                    to right,
                    rgba(23, 26, 32, 0),
                    var(--tm-surface)
                ) !important;
            }

            /*
             * Dark text detected by JavaScript.
             */
            .tm-gt-auto-text {
                color: var(--tm-text) !important;
            }

            button svg,
            [role="button"] svg,
            [role="tab"] svg,
            [role="option"] svg,
            .TYVfy svg {
                color: inherit !important;
            }

            button svg path:not([fill="none"]),
            [role="button"] svg path:not([fill="none"]),
            [role="tab"] svg path:not([fill="none"]),
            [role="option"] svg path:not([fill="none"]),
            .TYVfy svg path:not([fill="none"]) {
                fill: currentColor !important;
            }

            ::selection {
                background-color: var(--tm-selection) !important;
                color: #ffffff !important;
            }

            * {
                scrollbar-color:
                    var(--tm-scrollbar)
                    var(--tm-page) !important;
            }

            *::-webkit-scrollbar {
                width: 12px;
                height: 12px;
            }

            *::-webkit-scrollbar-track {
                background: var(--tm-page) !important;
            }

            *::-webkit-scrollbar-thumb {
                background: var(--tm-scrollbar) !important;
                border: 3px solid var(--tm-page) !important;
                border-radius: 10px;
            }

            *::-webkit-scrollbar-thumb:hover {
                background: var(--tm-scrollbar-hover) !important;
            }
        }
    `;

    function installStyle() {
        if (document.getElementById(STYLE_ID)) {
            return;
        }

        if (typeof GM_addStyle === 'function') {
            const style = GM_addStyle(css);

            if (style) {
                style.id = STYLE_ID;
            }

            return;
        }

        const style = document.createElement('style');

        style.id = STYLE_ID;
        style.textContent = css;

        (document.head || document.documentElement).appendChild(style);
    }

    function parseRgb(value) {
        const match = value.match(
            /^rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)(?:\s*[,/]\s*([\d.]+))?\s*\)$/i
        );

        if (!match) {
            return null;
        }

        return {
            r: Number(match[1]),
            g: Number(match[2]),
            b: Number(match[3]),
            a: match[4] === undefined
                ? 1
                : Number(match[4])
        };
    }

    function luminance({ r, g, b }) {
        return (
            0.2126 * r +
            0.7152 * g +
            0.0722 * b
        ) / 255;
    }

    function chroma({ r, g, b }) {
        return (
            Math.max(r, g, b) -
            Math.min(r, g, b)
        ) / 255;
    }

    function isBlueTint({ r, g, b }) {
        return b >= r + 10 && b >= g + 4;
    }

    function shouldSkip(element) {
        return element.matches([
            'img',
            'picture',
            'video',
            'canvas',
            'iframe',
            'object',
            'embed',
            'svg defs',
            'svg linearGradient',
            'svg radialGradient',
            'svg stop'
        ].join(','));
    }

    function hasLightGradient(backgroundImage) {
        if (
            !backgroundImage ||
            backgroundImage === 'none' ||
            !backgroundImage.includes('gradient')
        ) {
            return false;
        }

        return (
            /rgba?\(\s*25[0-5]\s*[,\s]+\s*25[0-5]\s*[,\s]+\s*25[0-5]/i.test(
                backgroundImage
            ) ||
            /rgba?\(\s*24\d\s*[,\s]+\s*24\d\s*[,\s]+\s*24\d/i.test(
                backgroundImage
            ) ||
            /#fff(?:fff)?\b/i.test(backgroundImage) ||
            /\bwhite\b/i.test(backgroundImage)
        );
    }

    function darkenElement(element) {
        if (
            !(element instanceof Element) ||
            shouldSkip(element)
        ) {
            return;
        }

        const style = getComputedStyle(element);

        /*
         * Detect bright backgrounds and assign classes.
         *
         * These classes may also be assigned in light mode,
         * but the corresponding CSS exists only inside
         * prefers-color-scheme: dark, so they have no effect
         * while light mode is active.
         */
        if (
            !element.classList.contains('tm-gt-auto-bg') &&
            !element.classList.contains('tm-gt-auto-bg-blue') &&
            style.backgroundImage === 'none'
        ) {
            const background = parseRgb(style.backgroundColor);

            if (
                background &&
                background.a >= 0.2 &&
                luminance(background) >= 0.68 &&
                chroma(background) <= 0.30
            ) {
                element.classList.add(
                    isBlueTint(background)
                        ? 'tm-gt-auto-bg-blue'
                        : 'tm-gt-auto-bg'
                );
            }
        }

        /*
         * Detect bright gradients.
         */
        if (
            !element.classList.contains('tm-gt-auto-gradient') &&
            hasLightGradient(style.backgroundImage)
        ) {
            element.classList.add('tm-gt-auto-gradient');
        }

        /*
         * Detect dark neutral-colored text.
         */
        if (!element.classList.contains('tm-gt-auto-text')) {
            const foreground = parseRgb(style.color);

            if (
                foreground &&
                foreground.a >= 0.5 &&
                luminance(foreground) <= 0.48 &&
                chroma(foreground) <= 0.18
            ) {
                element.classList.add('tm-gt-auto-text');
            }
        }
    }

    let scanScheduled = false;

    function scan(root = document) {
        installStyle();

        if (root instanceof Element) {
            darkenElement(root);
        }

        const elements = root.querySelectorAll
            ? root.querySelectorAll('*')
            : [];

        for (const element of elements) {
            darkenElement(element);
        }
    }

    function scheduleScan(root = document) {
        if (scanScheduled) {
            return;
        }

        scanScheduled = true;

        requestAnimationFrame(() => {
            scanScheduled = false;
            scan(root);
        });
    }

    installStyle();

    const start = () => {
        scan(document);

        const observer = new MutationObserver(mutations => {
            for (const mutation of mutations) {
                if (mutation.type === 'childList') {
                    for (const node of mutation.addedNodes) {
                        if (node instanceof Element) {
                            scheduleScan(node);
                        }
                    }
                } else if (mutation.target instanceof Element) {
                    scheduleScan(mutation.target);
                }
            }
        });

        observer.observe(document.documentElement, {
            childList: true,
            subtree: true,
            attributes: true,
            attributeFilter: [
                'style',
                'class',
                'hidden',
                'aria-hidden',
                'aria-selected',
                'aria-checked',
                'aria-expanded'
            ]
        });

        /*
         * Periodically recheck elements that are reused
         * by visibility toggling rather than being recreated.
         */
        window.setInterval(() => {
            scheduleScan(document);
        }, 2500);
    };

    if (document.readyState === 'loading') {
        document.addEventListener(
            'DOMContentLoaded',
            start,
            { once: true }
        );
    } else {
        start();
    }
})();

Tampermonkey Script to Fix the Issue Where Long Album Titles Disappear in YouTube Music

vast cow — Wed, 15 Jul 2026 06:36:09 +0000

In YouTube Music, long album titles may sometimes disappear from the screen even though the title element itself still exists in the page.

This Tampermonkey script fixes the display issue by overriding the relevant CSS, allowing long album titles to be displayed correctly.

What This Script Does

Fixes the issue where long album titles disappear.
Displays album titles on up to two lines, truncating any additional text.
Preserves YouTube Music's original layout as much as possible.

The script only affects long titles, leaving normal titles unchanged.

How to Use

Install Tampermonkey in your browser.
Create a new user script.
Paste the script into the editor and save it.
Reload YouTube Music.

If you want to apply the fix to local MHTML files, enable "Allow access to file URLs" in the Tampermonkey settings.

How It Works

The script overrides the CSS responsible for rendering album titles and applies the two-line truncation directly to the title element itself.

As a result, it prevents long album titles from being pushed outside the visible area and becoming invisible.

Summary

By installing this Tampermonkey script, you can easily fix the issue where long album titles disappear in YouTube Music.

Once installed, no additional configuration is required—the fix is applied automatically whenever you use YouTube Music.

// ==UserScript==
// @name         YouTube Music Long Album Title Display Fix
// @namespace    local.youtube-music-fixes
// @version      1.0.0
// @description  Fixes an issue where long album titles move outside the overflow clipping area and become invisible.
// @match        https://music.youtube.com/*
// @match        file:///*
// @grant        GM_addStyle
// @run-at       document-start
// ==/UserScript==

(() => {
  'use strict';

  const css = `
    /*
     * Do not apply line clamping to the title-group itself.
     * Instead, apply the two-line clamp to the actual title element.
     */
    ytmusic-two-row-item-renderer
      .title-group.ytmusic-two-row-item-renderer {
      display: block !important;
      -webkit-line-clamp: unset !important;
      -webkit-box-orient: initial !important;
      overflow: visible !important;
      max-height: none !important;
    }

    /*
     * Clamp the title element itself to two lines.
     */
    ytmusic-two-row-item-renderer
      .title.ytmusic-two-row-item-renderer {
      display: -webkit-box !important;
      -webkit-box-orient: vertical !important;
      -webkit-line-clamp: 2 !important;

      overflow: hidden !important;
      white-space: normal !important;
      text-overflow: ellipsis !important;

      max-height: calc(
        var(--ytmusic-responsive-font-size, 14px)
        * 2
        * var(--ytmusic-title-line-height, 1.3)
      ) !important;
    }

    /*
     * Prevent the inline-block link from becoming a single multi-line box
     * that gets pushed outside the parent's clipping region.
     */
    ytmusic-two-row-item-renderer
      .title.ytmusic-two-row-item-renderer
      > a.yt-simple-endpoint.yt-formatted-string {
      display: inline !important;
    }
  `;

  function installStyle() {
    if (typeof GM_addStyle === 'function') {
      GM_addStyle(css);
      return;
    }

    const style = document.createElement('style');
    style.id = 'ytmusic-long-album-title-fix';
    style.textContent = css;

    const target = document.head || document.documentElement;
    target.appendChild(style);
  }

  installStyle();
})();

How to Use Windows Mobile Hotspot Without an Internet Connection

vast cow — Fri, 03 Jul 2026 08:34:16 +0000

Purpose

This program is designed to make Windows always pass its internet connectivity check.

When Windows connects to a network, it performs a check to determine whether the network can actually reach the internet. If this check fails, Windows considers the network to have "No Internet."

As a result, some features, such as Mobile Hotspot, may not work properly in environments without an internet connection.

By using this program, you can make Windows successfully complete its connectivity check on the local PC. As a result, even in an environment without actual internet access, Windows will consider the system to be connected to the internet, making it possible to use Mobile Hotspot more easily.

How It Works

This program mainly performs the following two tasks.

1. Change the Windows Connectivity Check Host to localhost

Windows normally uses www.msftconnecttest.com for its internet connectivity check.

This program temporarily modifies the Windows registry so that the connectivity check is performed against localhost instead.

localhost refers to the local computer itself. This allows the connectivity check to be answered locally without requiring access to the external internet.

2. Start a Web Server for the Connectivity Check

The program starts a simple web server on the local PC.

When Windows accesses /connecttest.txt, the program returns the following content.

Microsoft Connect Test

This is the response that Windows expects. As a result, Windows determines that the internet connectivity check has succeeded.

Basic Usage

1. Run as Administrator

Because this program modifies the Windows registry, it must be run with administrator privileges.

Launch Command Prompt or PowerShell as an administrator and run the Python script.

2. Make Sure Port 80 Is Available

The program starts its web server on port 80.

If another web server or application is already using port 80, the program may fail to start. In that case, stop the application using port 80 before running the program.

3. Enable Mobile Hotspot

With the program running, enable Windows Mobile Hotspot.

Since Windows considers the internet connectivity check successful, Mobile Hotspot may be available even on networks without internet access.

Behavior on Exit

When the program exits, it attempts to restore the modified registry value.

At startup, it changes the connectivity check host to:

localhost

When the program exits, it restores the original host:

www.msftconnecttest.com

The restoration process is performed whenever possible, not only during a normal exit but also when the program is terminated with Ctrl+C or a similar signal.

Notes

This program makes Windows believe that its internet connectivity check has succeeded.

It does not provide actual internet access to external websites or online services. Its sole purpose is to satisfy Windows' connectivity check.

Because it modifies the registry, it should be used with care. If the program terminates unexpectedly, the registry setting may not be restored automatically. In that case, you must manually change the ActiveWebProbeHost value back to www.msftconnecttest.com.

Summary

This program allows Windows to successfully complete its internet connectivity test by responding locally on the PC.

As a result, Windows can recognize the system as having an active internet connection even when no actual internet connection is available.

Its primary use case is enabling Windows Mobile Hotspot in environments without internet access. Although the mechanism is relatively simple, it is useful for features that depend on Windows' internet connectivity detection.

#!/usr/bin/env python3
import atexit
import signal
import sys
import winreg
from aiohttp import web

CONNECT_TEST_BODY = b"Microsoft Connect Test"
NOT_FOUND_BODY = b"Page not found"

REDIRECT_LOCATION = "http://go.microsoft.com/fwlink/?LinkID=219472&clcid=0x409"

REG_PATH = r"SYSTEM\CurrentControlSet\Services\NlaSvc\Parameters\Internet"
REG_VALUE_NAME = "ActiveWebProbeHost"

STARTUP_PROBE_HOST = "localhost"
SHUTDOWN_PROBE_HOST = "www.msftconnecttest.com"


def set_active_web_probe_host(value: str) -> None:
    with winreg.OpenKey(
        winreg.HKEY_LOCAL_MACHINE,
        REG_PATH,
        0,
        winreg.KEY_SET_VALUE,
    ) as key:
        winreg.SetValueEx(
            key,
            REG_VALUE_NAME,
            0,
            winreg.REG_SZ,
            value,
        )


def restore_active_web_probe_host() -> None:
    try:
        set_active_web_probe_host(SHUTDOWN_PROBE_HOST)
        print(f"Restored {REG_VALUE_NAME} = {SHUTDOWN_PROBE_HOST}")
    except Exception as e:
        print(f"Failed to restore registry value: {e}", file=sys.stderr)


def setup_registry() -> None:
    set_active_web_probe_host(STARTUP_PROBE_HOST)
    print(f"Set {REG_VALUE_NAME} = {STARTUP_PROBE_HOST}")

    atexit.register(restore_active_web_probe_host)


def handle_exit_signal(signum, frame) -> None:
    restore_active_web_probe_host()
    sys.exit(0)


async def connecttest(request: web.Request) -> web.Response:
    return web.Response(
        status=200,
        body=CONNECT_TEST_BODY,
        headers={
            "Content-Type": "text/plain",
            "Cache-Control": "max-age=30, must-revalidate",
            "Connection": "keep-alive",
        },
    )


async def redirect(request: web.Request) -> web.Response:
    return web.Response(
        status=302,
        reason="Moved Temporarily",
        body=b"",
        headers={
            "Server": "AkamaiGHost",
            "Content-Length": "0",
            "Location": REDIRECT_LOCATION,
            "Connection": "keep-alive",
        },
    )


async def not_found(request: web.Request) -> web.Response:
    return web.Response(
        status=404,
        body=NOT_FOUND_BODY,
        headers={
            "Content-Type": "text/plain",
            "Connection": "keep-alive",
        },
    )


def create_app() -> web.Application:
    app = web.Application()

    app.router.add_get("/connecttest.txt", connecttest)
    app.router.add_get("/redirect", redirect)

    app.router.add_route("*", "/{tail:.*}", not_found)

    return app


if __name__ == "__main__":
    setup_registry()

    signal.signal(signal.SIGINT, handle_exit_signal)
    signal.signal(signal.SIGTERM, handle_exit_signal)

    web.run_app(
        create_app(),
        host="0.0.0.0",
        port=80,
        access_log=None,
    )

Updating the Rocky Linux Version

vast cow — Wed, 01 Jul 2026 04:42:29 +0000

Upgrading from Rocky Linux 9.5 to 9.6 can normally be done with a standard DNF update.

Check the Current Version

cat /etc/os-release

cat /etc/rocky-release

Update Package Metadata

First, refresh the repository metadata.

sudo dnf clean all
sudo dnf makecache

Update the Entire System

sudo dnf upgrade --refresh

sudo dnf update --refresh

Rocky Linux does not lock minor releases (9.5 → 9.6); it updates to the latest available 9.x release.

Reboot

If the kernel or systemd has been updated, reboot the system.

sudo reboot

Verify the Version

After rebooting, check the version.

cat /etc/rocky-release

Expected output:

Rocky Linux release 9.6 (Blue Onyx)

ELevate and Leapp Are Not Required

Since 9.5 → 9.6 is an update within the same major version,

Leapp
ELevate

are not required.

These tools are used for major version upgrades such as 8.x → 9.x or 9.x → 10.x.

If You Have Pinned a Specific Minor Version

You can check this with:

sudo dnf config-manager --dump | grep releasever

cat /etc/dnf/vars/releasever

If 9.5 is set, either remove it or change it to 9.

sudo rm -f /etc/dnf/vars/releasever

Then run:

sudo dnf upgrade --refresh

Display Order of GitHub Releases

vast cow — Fri, 26 Jun 2026 12:22:25 +0000

Conclusion

The display order of GitHub Releases is not based on the release title, not based on the tag name in simple lexical order, and not simply sorted by publication date in descending order.

If you want more predictable ordering for GitHub Releases, it is recommended to use SemVer-formatted tag names.

GitHub determines release ordering using a combination of the following criteria:

Aspect	What is Used
"Latest" determination	An explicitly selected `Set as latest release` / `make_latest`, or automatic SemVer-based detection
`/releases/latest`	The release considered "latest," excluding drafts and prereleases
Releases page display	Influenced by tag/commit dates and SemVer rather than publication date. The exact sorting algorithm is not officially documented.

In the GitHub UI, you can choose Set as latest release when creating a release. If you do not, the latest label is automatically assigned based on Semantic Versioning, according to the official documentation. (GitHub Docs)

Why Doesn't It Appear to Be Sorted by Date?

According to the GitHub REST API documentation for Get the latest release, the latest release is determined using created_at. However, created_at does not represent when the release was drafted or published—it represents the date of the commit associated with the release. (GitHub Docs)

For example:

Release A published on 2026-06-26
  -> The tag points to an old commit from 2025

Release B published on 2026-06-20
  -> The tag points to a newer commit from 2026

In this case, although Release A has the newer publication date, GitHub may still treat Release B as the newer release.

Is It Sorted by Tag Name?

No, not in simple lexical order.

However, if the tag name can be interpreted as a Semantic Version, it does influence GitHub's ordering.

The official GitHub Changelog explains that, before explicit "latest" selection was introduced, the latest release was determined by the most recent release date, with Semantic Versioning used as a tie-breaker when releases shared the same date. GitHub now allows maintainers to explicitly designate the latest release. (The GitHub Blog)

A GitHub Community discussion also explains that releases created on the same day are expected to be ordered by SemVer, and that GitHub primarily relies on tag/commit dates rather than the release object's publication timestamp. (GitHub)

As a result, tag names like the following can produce unexpected ordering:

release/69.3
build-20240626
2024-06-26-001
v1.0
v1.0.0-beta.10
v1.0.0-beta.9

If you want GitHub to recognize version ordering correctly, use standard SemVer tags such as:

v1.2.3
v1.2.4
v1.3.0
v2.0.0

Is It Sorted by Title?

No.

The release title (name) is purely a display field. In the GitHub API, tag_name and name are separate fields. For ordering and latest-release determination, the relevant fields are the tag, SemVer, created_at, published_at, and make_latest—not the release title. (GitHub Docs)

Notes When Using the API

The GET /repos/{owner}/{repo}/releases endpoint (List releases) provides pagination parameters such as per_page and page, but it does not support explicit sorting parameters such as sort or direction. (GitHub Docs)

GitHub Community discussions also note that the API does not guarantee a particular ordering, so applications should not depend on the response order. (GitHub)

Therefore, if your application requires deterministic ordering, you should sort the releases yourself.

gh release list \
  --repo OWNER/REPO \
  --limit 100 \
  --json tagName,name,publishedAt,createdAt,isLatest,isPrerelease,isDraft \
  --jq '.[] | [.tagName, .name, .publishedAt, .createdAt, .isLatest, .isPrerelease, .isDraft] | @tsv'

gh release list can output fields such as createdAt, publishedAt, tagName, name, isLatest, isPrerelease, and isDraft as JSON. (GitHub CLI)

Practical Recommendations

If you want your releases to appear in a predictable order, the following practices are recommended:

Use SemVer-formatted tags

For example:

   v1.2.3

Avoid creating releases for old commits after newer releases

GitHub's ordering can be influenced by the tag's commit date rather than the publication date.

Explicitly mark the release as the latest when appropriate

In the UI, select Set as latest release. Via the API, use make_latest: true. The make_latest field accepts true, false, or legacy, and draft or prerelease releases cannot be marked as the latest. (GitHub Docs)

Do not rely on GitHub's response order

Sort releases yourself according to your application's requirements—for example, by publishedAt, createdAt, or Semantic Version.

In summary, the order of GitHub Releases is determined neither by the release title, nor by the tag name in simple lexical order, nor by publication date alone. Instead, it is influenced by GitHub's internal handling of the latest release, Semantic Versioning, and tag/commit dates.

Bookmarklet for Editing the Prompt Input Field in a Separate Window

vast cow — Fri, 26 Jun 2026 05:30:45 +0000

This bookmarklet lets you open the prompt input field on a page in a separate window, where you can edit it in a larger text area. It reads the current contents of the input field and displays them as the initial value in the editing window. After making your changes, click the Set button to apply them back to the original page.

Purpose

Editing long prompts in a small browser input field can be inconvenient. This bookmarklet opens a dedicated editing window with a larger, easier-to-read text area, making it more comfortable to review and edit your prompt.

Typical use cases include:

Editing an existing prompt in a separate window
Making long prompts easier to read and organize
Working more comfortably with multi-line text
Applying the edited content back to the original input field

How to Use

First, save the JavaScript code as a bookmarklet in your browser. Once it has been added, open the target page and run the bookmarklet.

When executed, an editing window opens with the current page title displayed as its heading. The contents of the original page's prompt input field are preloaded into the text area.

After editing the text, click the Set button. The updated content will be written back to the prompt input field on the original page, and the editing window will close.

Automatic Theme Switching

The editing window automatically switches between light and dark themes based on your browser or operating system's theme settings.

The light theme uses a white background with black text, while the dark theme uses a dark background with light-colored text. This allows the editor to match the appearance of your usual environment.

Loading the Current Value

When the bookmarklet is executed, it first reads the current contents of #prompt-textarea on the original page. That content is embedded directly into the generated HTML as the initial value of the <textarea>.

As a result, the editing window displays the current prompt immediately when it opens, without needing to retrieve the content from the original page afterward.

Applying Edited Content

When you click the Set button, the text entered in the editing window is split into individual lines and written back to the prompt input field on the original page.

Blank lines are preserved, making it easy to work with multi-line prompts and structured text.

Cleanup

The editing window is created from a temporary HTML document stored as a Blob and opened through its generated URL. Once processing is complete, the temporary URL is released using URL.revokeObjectURL().

This prevents unnecessary temporary URLs from remaining in memory. The URL is also revoked if the popup cannot be opened or if an error occurs during processing.

Notes

This bookmarklet assumes that the target page contains an element with the ID #prompt-textarea. If the element cannot be found, an error message is displayed and no further processing is performed.

If your browser blocks pop-up windows, the editing window may fail to open. In that case, you will need to allow pop-ups for the target page.

(() => {
  const escapeHtml = (s) =>
    (s || '')
      .replace(/&/g, '&amp;')
      .replace(/</g, '&lt;')
      .replace(/>/g, '&gt;');
  const promptTextarea = document.querySelector('#prompt-textarea');
  if (!promptTextarea) {
    alert('Could not find #prompt-textarea');
    return;
  }
  const escapedParentTitle = escapeHtml(document.title || 'Prompt Setter');
  const initialText = ((el) => {
    const nodes = Array.from(el.childNodes);
    return nodes.length
      ? nodes
          .map((node) =>
            3 === node.nodeType
              ? node.textContent || ''
              : 'BR' === node.nodeName
                ? ''
                : node.textContent || '',
          )
          .join('\n')
      : el.innerText || el.textContent || '';
  })(promptTextarea);
  const blob = new Blob(
    [
      `<!doctype html>\n<html lang="en">\n<head>\n  <meta charset="utf-8">\n  <title>${escapedParentTitle}</title>\n  <style>\n    :root {\n      color-scheme: light dark;\n      --bg: #ffffff;\n      --fg: #111111;\n      --muted: #333333;\n      --border: #cccccc;\n      --textarea-bg: #ffffff;\n      --textarea-fg: #111111;\n      --button-bg: #f3f3f3;\n      --button-fg: #111111;\n      --button-border: #999999;\n    }\n\n    @media (prefers-color-scheme: dark) {\n      :root {\n        --bg: #111111;\n        --fg: #eeeeee;\n        --muted: #cccccc;\n        --border: #444444;\n        --textarea-bg: #1e1e1e;\n        --textarea-fg: #eeeeee;\n        --button-bg: #2a2a2a;\n        --button-fg: #eeeeee;\n        --button-border: #666666;\n      }\n    }\n\n    body {\n      font-family: sans-serif;\n      margin: 16px;\n      background: var(--bg);\n      color: var(--fg);\n    }\n\n    .page-title {\n      font-size: 24px;\n      font-weight: 700;\n      line-height: 1.4;\n      margin: 0 0 16px;\n      word-break: break-word;\n    }\n\n    textarea {\n      width: 100%;\n      height: 240px;\n      box-sizing: border-box;\n      font-family: monospace;\n      font-size: 14px;\n      background: var(--textarea-bg);\n      color: var(--textarea-fg);\n      border: 1px solid var(--border);\n    }\n\n    button {\n      margin-top: 12px;\n      padding: 8px 16px;\n      font-size: 14px;\n      background: var(--button-bg);\n      color: var(--button-fg);\n      border: 1px solid var(--button-border);\n      border-radius: 4px;\n      cursor: pointer;\n    }\n\n    button:hover {\n      filter: brightness(0.96);\n    }\n\n    @media (prefers-color-scheme: dark) {\n      button:hover {\n        filter: brightness(1.15);\n      }\n    }\n\n    .msg {\n      margin-top: 12px;\n      color: var(--muted);\n      white-space: pre-wrap;\n    }\n  </style>\n</head>\n<body>\n  <div class="page-title">${escapedParentTitle}</div>\n  <textarea id="usertext" placeholder="Enter text here">${escapeHtml(initialText)}</textarea>\n  <br>\n  <button id="setButton" type="button">Set</button>\n  <div class="msg" id="msg"></div>\n</body>\n</html>`,
    ],
    { type: 'text/html' },
  );
  const url = URL.createObjectURL(blob);
  let revoked = !1;
  const revokeUrl = () => {
    if (!revoked) {
      URL.revokeObjectURL(url);
      revoked = !0;
    }
  };
  const child = window.open(url, '_blank');
  if (!child) {
    revokeUrl();
    alert('Could not open popup');
    return;
  }
  const setup = () => {
    try {
      const childDoc = child.document;
      const usertextEl = childDoc.getElementById('usertext');
      const setButton = childDoc.getElementById('setButton');
      const msgEl = childDoc.getElementById('msg');
      if (!usertextEl || !setButton || !msgEl) {
        setTimeout(setup, 50);
        return;
      }
      try {
        child.addEventListener('beforeunload', revokeUrl, { once: !0 });
      } catch (_) {}
      setButton.addEventListener('click', async () => {
        try {
          if (!child.opener || child.opener.closed)
            throw new Error('Cannot access parent window');
          const openerDoc = child.opener.document;
          const promptTextarea = openerDoc.querySelector('#prompt-textarea');
          if (!promptTextarea)
            throw new Error('Could not find #prompt-textarea');
          const usertext = usertextEl.value;
          const newNodes = usertext
            .replace(/\r\n/g, '\n')
            .split('\n')
            .map((promptLine) => {
              const p = openerDoc.createElement('p');
              '' === promptLine
                ? p.appendChild(openerDoc.createElement('br'))
                : (p.textContent = promptLine);
              return p;
            });
          promptTextarea.replaceChildren(...newNodes);
          await new Promise((resolve) => setTimeout(resolve, 0));
          promptTextarea.lastChild &&
            promptTextarea.lastChild.scrollIntoView &&
            promptTextarea.lastChild.scrollIntoView();
          revokeUrl();
          child.close();
        } catch (err) {
          msgEl.textContent = 'Error: ' + err.message;
          revokeUrl();
        }
      });
    } catch (e) {
      setTimeout(setup, 50);
    }
  };
  setup();
})();

Launching an MSVC PowerShell

vast cow — Fri, 26 Jun 2026 03:07:53 +0000

This example shows how to start a PowerShell session that is already configured for the Microsoft Visual C++ (MSVC) development environment.

Instead of opening the Visual Studio Developer PowerShell manually, the script automatically finds a suitable Visual Studio or Build Tools installation and starts an MSVC-enabled PowerShell session.

Purpose

The script is useful when you want to:

Start an MSVC development environment from a script.
Use Visual Studio Build Tools without opening the Visual Studio IDE.
Select a specific target or host architecture.
Use the latest installed Visual Studio or Build Tools automatically.

How It Works

The PowerShell script performs the following steps:

Parses command-line options.
Searches for a Visual Studio installation by using vswhere.exe.
Loads the Visual Studio Developer Shell module.
Starts the developer shell by calling Enter-VsDevShell.

If no suitable installation is found, the script prints an error message explaining what components are required.

Command-Line Options

The script supports the following options:

Option	Description
`--arch`	Target architecture (`x86`, `amd64`, `arm`, or `arm64`).
`--host-arch`	Host architecture.
`--product`	Visual Studio product to search for. The default is `Microsoft.VisualStudio.Product.BuildTools`. Use `*` to search all installed Visual Studio products.
`--prerelease`	Include prerelease Visual Studio installations.
`--help`	Display usage information.

Starting the Script

The following shell script starts the PowerShell script:

#!/bin/sh
exec /mnt/c/windows/system32/WindowsPowerShell/v1.0/powershell.exe \
    -NoLogo \
    -NoExit \
    -ExecutionPolicy Bypass \
    -File ./msvc-devshell.ps1

Running this script opens a PowerShell session with the MSVC development environment already configured. Because the session is started with -NoExit, the PowerShell window remains open after initialization, allowing you to run build tools such as cl, link, and nmake.

powershell.exe -NoLogo -NoExit -ExecutionPolicy Bypass -File ./msvc-devshell.ps1

$ErrorActionPreference = "Stop"

$Arch = "amd64"
$HostArch = "amd64"
$Product = "Microsoft.VisualStudio.Product.BuildTools"
$Prerelease = $false

function Show-Usage {
@"
Usage:
  msvc-pwsh.ps1 [options]

Options:
  --arch ARCH          Target architecture: x86, amd64, arm, arm64
  --host-arch ARCH     Host architecture: x86, amd64, arm, arm64
  --product PRODUCT    Visual Studio product id.
                       Default: Microsoft.VisualStudio.Product.BuildTools
                       Use "*" to search all Visual Studio products.
  --prerelease         Include prerelease Visual Studio instances.
  -h, --help           Show this help.
"@
}

$argv = @($args)

$i = 0
while ($i -lt $argv.Count) {
  switch ($argv[$i]) {
    { $_ -in @("-arch", "--arch") } {
      if ($i + 1 -ge $argv.Count) {
        [Console]::Error.WriteLine("missing value for $($argv[$i])")
        exit 2
      }
      $Arch = $argv[$i + 1]
      $i += 2
      continue
    }

    { $_ -in @("-host_arch", "--host-arch") } {
      if ($i + 1 -ge $argv.Count) {
        [Console]::Error.WriteLine("missing value for $($argv[$i])")
        exit 2
      }
      $HostArch = $argv[$i + 1]
      $i += 2
      continue
    }

    { $_ -in @("-product", "--product") } {
      if ($i + 1 -ge $argv.Count) {
        [Console]::Error.WriteLine("missing value for $($argv[$i])")
        exit 2
      }
      $Product = $argv[$i + 1]
      $i += 2
      continue
    }

    "--prerelease" {
      $Prerelease = $true
      $i += 1
      continue
    }

    { $_ -in @("-h", "--help") } {
      Show-Usage
      exit 0
    }

    default {
      [Console]::Error.WriteLine("unknown argument: $($argv[$i])")
      exit 2
    }
  }
}

$validArch = @("x86", "amd64", "arm", "arm64")

if ($Arch -notin $validArch) {
  [Console]::Error.WriteLine("invalid --arch: $Arch")
  exit 2
}

if ($HostArch -notin $validArch) {
  [Console]::Error.WriteLine("invalid --host-arch: $HostArch")
  exit 2
}

$programFilesX86 = ${Env:ProgramFiles(x86)}
if (-not $programFilesX86) {
  $programFilesX86 = "C:\Program Files (x86)"
}

$vswhere = Join-Path $programFilesX86 "Microsoft Visual Studio\Installer\vswhere.exe"

if (-not (Test-Path -LiteralPath $vswhere -PathType Leaf)) {
  [Console]::Error.WriteLine("vswhere.exe not found: $vswhere")
  exit 1
}

$vswhereArgs = @(
  "-latest",
  "-products", $Product,
  "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
  "-property", "installationPath"
)

if ($Prerelease) {
  $vswhereArgs += "-prerelease"
}

$installationPath = & $vswhere @vswhereArgs |
  ForEach-Object { $_ -replace "`r$", "" } |
  Select-Object -First 1

if (-not $installationPath) {
  [Console]::Error.WriteLine(@"
Visual Studio / Build Tools with MSVC was not found.

Try:
  .\msvc-pwsh.ps1 --product "*"

Or install:
  - Visual Studio Build Tools
  - MSVC C++ build tools
  - Windows SDK
"@)
  exit 1
}

$devshellDll = Join-Path $installationPath "Common7\Tools\Microsoft.VisualStudio.DevShell.dll"

if (-not (Test-Path -LiteralPath $devshellDll -PathType Leaf)) {
  [Console]::Error.WriteLine("DevShell module not found: $devshellDll")
  exit 1
}

Set-Location $Env:USERPROFILE

Import-Module $devshellDll

Enter-VsDevShell `
  -VsInstallPath $installationPath `
  -SkipAutomaticLocation `
  -Arch $Arch `
  -HostArch $HostArch `
  -DevCmdArguments "-no_logo"

Running Waydroid Inside Weston

vast cow — Thu, 25 Jun 2026 09:59:21 +0000

Waydroid can be started inside a Weston session by launching Weston with the Wayland backend, starting the Waydroid session, and then opening the full Waydroid user interface.

This setup is useful when you want to run Waydroid in a controlled Wayland environment instead of directly on the main desktop session.

Purpose

The purpose of this setup is to run Waydroid inside Weston, a lightweight Wayland compositor. Weston provides a separate graphical environment where Waydroid can display its Android interface.

This can be useful for testing, kiosk-style environments, or systems where you want Waydroid to run in a dedicated display session.

How to Use It

1. Start Weston

First, start Weston using the Wayland backend and kiosk shell:

weston --backend=wayland-backend.so --shell=kiosk-shell.so --idle-time=0

This starts Weston as a nested Wayland compositor. The kiosk shell provides a simple fullscreen-style environment, and --idle-time=0 prevents Weston from entering an idle state.

2. Start the Waydroid Session

Next, start the Waydroid session using the Weston Wayland display:

WAYLAND_DISPLAY=wayland-1 waydroid session start

The WAYLAND_DISPLAY=wayland-1 setting tells Waydroid to use the Wayland display created by Weston.

3. Show the Waydroid Full UI

After the Waydroid session has started, open the full Waydroid interface:

waydroid show-full-ui

This displays the Android interface inside the Weston environment.

Stopping Waydroid

When you are finished using Waydroid, it is better to shut down the Android environment first and then stop the Waydroid session.

1. Shut Down Android Inside Waydroid

Run the following command:

waydroid shell -- svc power shutdown

This sends a shutdown command to the Android system running inside Waydroid. It is similar to powering off an Android device.

2. Stop the Waydroid Session

After Android has been shut down, stop the Waydroid session:

waydroid session stop

This stops the active Waydroid session on the host system.

Notes

The commands should usually be run in order. Weston must be running before starting the Waydroid session, because Waydroid needs the Weston Wayland display to show its interface.

When stopping Waydroid, shut down Android first with waydroid shell -- svc power shutdown, then stop the session with waydroid session stop.

Depending on your system, the Wayland display name may be different from wayland-1. If the command does not work, check the available Wayland display socket and adjust WAYLAND_DISPLAY accordingly.

Summary

Running Waydroid inside Weston is a simple way to launch Android in a dedicated Wayland environment. Start Weston first, point Waydroid to the Weston display, and then open the full Waydroid UI.

To stop it cleanly, shut down Android inside Waydroid first, and then stop the Waydroid session.

Plotting Stream Data Directly in the Terminal

vast cow — Wed, 24 Jun 2026 08:36:00 +0000

This tool is a small command-line program for plotting live numeric data directly inside a terminal. It reads values from standard input, sends them to gnuplot, and displays a simple text-based graph that updates as new data arrives.

Purpose

The purpose of this tool is to make stream data easy to observe without opening a separate graphical window.

It is useful when you want to monitor changing values in real time, such as sensor readings, log output, benchmark results, or values produced by another command-line program.

Because the graph is drawn inside the terminal, it can be used in simple shell workflows and remote environments where a graphical desktop may not be available.

How It Works

The program reads lines from standard input. Each line is expected to contain numeric data.

For every valid numeric value, the program records the time since startup and plots the value against elapsed time. The graph is updated automatically whenever new data is received.

Only a limited number of recent points are kept. By default, the tool stores up to 200 points, which keeps the display focused on recent changes.

Input Format

The tool accepts comma-separated or tab-separated input.

For example, this input can be plotted:

1.2
1.5
1.8
2.1

It can also read the first column from CSV-like data:

1.2,ok
1.5,ok
1.8,ok
2.1,ok

If a line does not contain a valid numeric value, it is ignored.

Basic Usage

Save the script as a file, for example:

stream-plot.py

Make it executable:

chmod +x stream-plot.py

Then pipe numeric data into it:

python3 generate_values.py | ./stream-plot.py

A simple live plot will appear in the terminal.

Example

A simple test can be done with a shell loop:

while true; do
  echo $RANDOM
  sleep 1
done | ./stream-plot.py

This sends a new random value every second. The terminal plot updates each time a new value is received.

Terminal Resizing

The tool detects terminal size and adjusts the plot area. If the terminal window is resized, the plot size is updated so the graph continues to fit the available space.

Stopping the Tool

The tool can be stopped with:

Ctrl+C

It handles shutdown by closing the gnuplot process cleanly.

Requirements

This tool requires:

gnuplot

It also uses Python 3 and standard Python libraries such as asyncio, csv, and signal.

Summary

This terminal stream plotting tool provides a simple way to watch live numeric data from the command line. It is lightweight, works with standard input, and is suitable for quick monitoring tasks where a full plotting application is unnecessary.

#!/usr/bin/env python3

import asyncio
import csv
import io
import shutil
import signal
import sys
import time
import uuid
from collections import deque


def get_plot_size():
    size = shutil.get_terminal_size(fallback=(120, 30))

    width = max(20, size.columns)
    height = max(10, size.lines - 1)

    return width, height


class StreamGnuplot:
    def __init__(
        self,
        *,
        max_points=200,
        width=120,
        height=30,
        value_column=0,
        # title="stdin stream",
        # ylabel="value",
    ):
        self.max_points = max_points
        self.width = width
        self.height = height
        self.value_column = value_column
        # self.title = title
        # self.ylabel = ylabel

        self.start_time = time.monotonic()
        self.points = deque(maxlen=max_points)

        self.proc = None
        self._lock = asyncio.Lock()

        self._first_draw = True
        self._resize_requested = False

    async def start(self):
        self.proc = await asyncio.create_subprocess_exec(
            "gnuplot",
            stdin=asyncio.subprocess.PIPE,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )

        await self._write(self._gnuplot_setup_script())

    def request_resize(self):
        self._resize_requested = True

    def _gnuplot_setup_script(self):

        # set title "{self.title}"
        # set ylabel "{self.ylabel}"
        return f"""
set terminal dumb {self.width} {self.height}
set print "-"
set xlabel "time since start [s]"
set grid
set key off
"""

    async def _apply_resize_if_needed(self):
        if not self._resize_requested:
            return

        self._resize_requested = False

        new_width, new_height = get_plot_size()

        if new_width == self.width and new_height == self.height:
            return

        self.width = new_width
        self.height = new_height

        await self._write(f"set terminal dumb {self.width} {self.height}\n")

        # ここでは _first_draw を戻さない。
        # 「1回目だけ \033[H しない」という条件を維持する。

    async def stop(self):
        if self.proc is None:
            return

        try:
            await self._write("exit\n")
        except Exception:
            pass

        try:
            await asyncio.wait_for(self.proc.wait(), timeout=1.0)
        except asyncio.TimeoutError:
            self.proc.terminate()
            await self.proc.wait()

    async def _write(self, text):
        if self.proc is None or self.proc.stdin is None:
            raise RuntimeError("gnuplot is not running")

        self.proc.stdin.write(text.encode("utf-8"))
        await self.proc.stdin.drain()

    async def add_value(self, value):
        elapsed = time.monotonic() - self.start_time
        self.points.append((elapsed, value))
        await self.replot()

    async def replot(self):
        if not self.points:
            return

        async with self._lock:
            await self._apply_resize_if_needed()

            marker = f"__GPLOT_DONE_{uuid.uuid4().hex}__"

            data = "\n".join(
                f"{x:.6f} {y:.12g}"
                for x, y in self.points
            )

            script = f"""
plot "-" using 1:2 with lines
{data}
e
print "{marker}"
"""

            await self._write(script)

            plot_text = await self._read_until_marker(marker)
            self._draw_to_terminal(plot_text)

    async def _read_until_marker(self, marker):
        if self.proc is None or self.proc.stdout is None:
            raise RuntimeError("gnuplot stdout is not available")

        lines = []

        while True:
            raw = await self.proc.stdout.readline()

            if raw == b"":
                raise RuntimeError("gnuplot stdout closed unexpectedly")

            line = raw.decode("utf-8", errors="replace")

            if line.rstrip("\r\n") == marker:
                break

            lines.append(line)

        return "".join(lines)

    def _draw_to_terminal(self, plot_text):
        """
        初回は cursor home せず、その場にプロットを出力する。
        2回目以降は左上へ戻ってプロットテキストを上書きする。

        プロットテキスト最後の改行だけを出力しない。
        sys.stdout.write("\\033[J") は使わない。
        """
        if self._first_draw:
            self._first_draw = False
        else:
            sys.stdout.write("\033[H")

        if plot_text.endswith("\r\n"):
            plot_text = plot_text[:-2]
        elif plot_text.endswith("\n") or plot_text.endswith("\r"):
            plot_text = plot_text[:-1]

        sys.stdout.write(plot_text)
        sys.stdout.flush()


def detect_delimiter(line):
    if "\t" in line:
        return "\t"
    return ","


def parse_numeric_value(line, value_column):
    line = line.strip()

    if not line:
        return None

    delimiter = detect_delimiter(line)

    reader = csv.reader(io.StringIO(line), delimiter=delimiter)
    row = next(reader, None)

    if not row:
        return None

    try:
        return float(row[value_column])
    except (ValueError, IndexError):
        return None


async def read_stdin_stream(plotter):
    loop = asyncio.get_running_loop()

    while True:
        line = await loop.run_in_executor(None, sys.stdin.readline)

        if line == "":
            break

        value = parse_numeric_value(line, plotter.value_column)

        if value is None:
            continue

        await plotter.add_value(value)


async def drain_stderr(proc):
    if proc.stderr is None:
        return

    while True:
        raw = await proc.stderr.readline()

        if raw == b"":
            break

        # sys.stderr.write(raw.decode("utf-8", errors="replace"))
        # sys.stderr.flush()


async def main():
    width, height = get_plot_size()

    plotter = StreamGnuplot(
        max_points=200,
        width=width,
        height=height,
        value_column=0,
        # title="stdin stream",
        # ylabel="value",
    )

    stop_event = asyncio.Event()

    def request_stop():
        stop_event.set()

    loop = asyncio.get_running_loop()

    for sig in (signal.SIGINT, signal.SIGTERM):
        try:
            loop.add_signal_handler(sig, request_stop)
        except NotImplementedError:
            pass

    try:
        loop.add_signal_handler(signal.SIGWINCH, plotter.request_resize)
    except (AttributeError, NotImplementedError):
        pass

    await plotter.start()

    stderr_task = asyncio.create_task(drain_stderr(plotter.proc))
    reader_task = asyncio.create_task(read_stdin_stream(plotter))
    stop_task = asyncio.create_task(stop_event.wait())

    done, pending = await asyncio.wait(
        {reader_task, stop_task},
        return_when=asyncio.FIRST_COMPLETED,
    )

    for task in pending:
        task.cancel()

    stderr_task.cancel()

    await plotter.stop()


if __name__ == "__main__":
    asyncio.run(main())

Registering the Legacy Windows Photo Viewer for Picture Files

vast cow — Wed, 24 Jun 2026 05:59:54 +0000

Windows Photo Viewer is the classic image viewer that was used in earlier versions of Windows. Some users still prefer it because it is simple, fast, and familiar. On newer Windows systems, it may not appear as an available app for opening picture files by default.

The registry file shown here is used to register the legacy Windows Photo Viewer as an application for picture file types. After applying it, Windows can show Windows Photo Viewer as an option when choosing an app to open images.

Purpose

The purpose of this registry entry is to make photoviewer.dll available as an image-viewing application in Windows.

It adds Windows Photo Viewer to the current user’s application list and defines how Windows should open and print image files with it. This allows the user to select Windows Photo Viewer from the “Open with” menu or set it as the default app for supported picture file types.

What It Does

This registry file adds entries under:

HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll

Because it uses HKEY_CURRENT_USER, the change applies only to the current Windows user account. It does not affect all users on the computer.

The registry entries define two main actions:

Open Images

The open section tells Windows how to launch Windows Photo Viewer when an image file is opened.

It uses rundll32.exe to call the Windows Photo Viewer library and open the selected picture in full-screen image-viewing mode.

This makes Windows Photo Viewer available as an app that can open picture files.

Print Images

The print section registers a print action for Windows Photo Viewer.

This allows Windows to recognize that Windows Photo Viewer can also be used when printing image files. The NeverDefault value helps prevent this print action from becoming the default print behavior automatically.

How to Use It

To use this registry content, save it as a .reg file.

For example:

register-photo-viewer.reg

Then double-click the file and allow Windows to add the information to the registry.

After applying the file, you can choose Windows Photo Viewer for image files by doing the following:

Right-click a picture file.
Select Open with.
Choose Choose another app.
Select Windows Photo Viewer if it appears.
Optionally enable Always use this app to make it the default for that file type.

Important Note

Editing the Windows Registry can affect how Windows behaves. Before applying a registry file, make sure the contents are trusted and suitable for your system.

This registry file is intended to register the legacy Windows Photo Viewer for the current user only. It does not install a new program; it only makes an existing Windows component available as an application option for picture files.

Summary

This registry file restores Windows Photo Viewer as a selectable app for image files. It is useful for users who prefer the classic Windows image viewer instead of newer photo apps. Once registered, Windows Photo Viewer can be selected from the “Open with” menu and used to open supported picture files.

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll]

[HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll\shell]

[HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll\shell\open]
"MuiVerb"="@photoviewer.dll,-3043"

[HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll\shell\open\command]
@=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,52,00,6f,00,6f,00,74,00,25,\
  00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,5c,00,72,00,75,00,\
  6e,00,64,00,6c,00,6c,00,33,00,32,00,2e,00,65,00,78,00,65,00,20,00,22,00,25,\
  00,50,00,72,00,6f,00,67,00,72,00,61,00,6d,00,46,00,69,00,6c,00,65,00,73,00,\
  25,00,5c,00,57,00,69,00,6e,00,64,00,6f,00,77,00,73,00,20,00,50,00,68,00,6f,\
  00,74,00,6f,00,20,00,56,00,69,00,65,00,77,00,65,00,72,00,5c,00,50,00,68,00,\
  6f,00,74,00,6f,00,56,00,69,00,65,00,77,00,65,00,72,00,2e,00,64,00,6c,00,6c,\
  00,22,00,2c,00,20,00,49,00,6d,00,61,00,67,00,65,00,56,00,69,00,65,00,77,00,\
  5f,00,46,00,75,00,6c,00,6c,00,73,00,63,00,72,00,65,00,65,00,6e,00,20,00,25,\
  00,31,00,00,00

[HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll\shell\open\DropTarget]
"Clsid"="{FFE2A43C-56B9-4bf5-9A79-CC6D4285608A}"

[HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll\shell\print]
"NeverDefault"=""

[HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll\shell\print\command]
@=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,52,00,6f,00,6f,00,74,00,25,\
  00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,5c,00,72,00,75,00,\
  6e,00,64,00,6c,00,6c,00,33,00,32,00,2e,00,65,00,78,00,65,00,20,00,22,00,25,\
  00,50,00,72,00,6f,00,67,00,72,00,61,00,6d,00,46,00,69,00,6c,00,65,00,73,00,\
  25,00,5c,00,57,00,69,00,6e,00,64,00,6f,00,77,00,73,00,20,00,50,00,68,00,6f,\
  00,74,00,6f,00,20,00,56,00,69,00,65,00,77,00,65,00,72,00,5c,00,50,00,68,00,\
  6f,00,74,00,6f,00,56,00,69,00,65,00,77,00,65,00,72,00,2e,00,64,00,6c,00,6c,\
  00,22,00,2c,00,20,00,49,00,6d,00,61,00,67,00,65,00,56,00,69,00,65,00,77,00,\
  5f,00,46,00,75,00,6c,00,6c,00,73,00,63,00,72,00,65,00,65,00,6e,00,20,00,25,\
  00,31,00,00,00

[HKEY_CURRENT_USER\SOFTWARE\Classes\Applications\photoviewer.dll\shell\print\DropTarget]
"Clsid"="{60fd46de-f830-4894-a628-6fa81bc0190d}"

How to Use `getopt` with `getopt.h` / `getopt.c` in MSVC and Licensing Considerations

vast cow — Tue, 23 Jun 2026 10:16:23 +0000

Prerequisites

The Windows MSVC environment does not provide the POSIX-style getopt.h / getopt() commonly used on Unix-like systems. As a result, when building C/C++ code originally written for Linux with MSVC, you will typically encounter errors such as:

fatal error C1083: cannot open include file: 'getopt.h'

Even if you add the header file, linking will still fail unless implementations of getopt(), getopt_long(), optind, optarg, and related symbols are available.

MSYS2 UCRT64 includes a MinGW-w64-derived getopt.h. The MSYS2 package mingw-w64-ucrt-x86_64-headers is distributed as MinGW-w64 headers for Windows and belongs to the UCRT64 repository. The package license is listed as ZPL-2.1 AND LGPL-2.1-or-later. (MSYS2 Packages)

However, the getopt.h file itself contains a disclaimer stating that no copyright has been assigned and that it has been placed in the Public Domain. (GitHub)

This article explains how to incorporate this MinGW-w64-derived getopt.h and getopt.c into an MSVC project to use getopt() and getopt_long().

Conclusion

The safest way to use getopt with MSVC is the following structure:

your_project/
  include/
    getopt.h
  src/
    getopt.c
    main.c

Then compile getopt.c as part of your project:

cl /Iinclude src\main.c src\getopt.c

What you should not do is add MSYS2's entire /ucrt64/include or /ucrt64/lib directories to an MSVC project. This mixes MinGW-w64 and MSVC CRTs, headers, and libraries, which can easily lead to build and link problems.

1. Prepare the Files

Copy the following two files derived from MinGW-w64 into your project:

getopt.h
getopt.c

If MSYS2 UCRT64 is installed, getopt.h is typically located at:

C:\msys64\ucrt64\include\getopt.h

However, instead of adding the entire C:\msys64\ucrt64\include directory to the include path of an MSVC project, it is safer to copy only the required getopt.h into your project.

getopt.c is the implementation file from the MinGW-w64 CRT. The MSYS2 package mingw-w64-ucrt-x86_64-crt is distributed as MinGW-w64 CRT for Windows, and its package license is listed as ZPL-2.1. (MSYS2 Packages)

However, the getopt.c file itself contains a permissive license originating from Todd C. Miller and BSD-style license text originating from NetBSD. These licenses permit redistribution in source and binary form, provided that copyright notices, conditions, and disclaimers are retained or reproduced. (GitHub)

2. Minimal Example

`main.c`

#include <stdio.h>
#include <getopt.h>

int main(int argc, char *argv[])
{
    int opt;

    while ((opt = getopt(argc, argv, "ab:c")) != -1) {
        switch (opt) {
        case 'a':
            printf("option -a\n");
            break;

        case 'b':
            printf("option -b with argument: %s\n", optarg);
            break;

        case 'c':
            printf("option -c\n");
            break;

        default:
            printf("usage: %s [-a] [-b value] [-c]\n", argv[0]);
            return 1;
        }
    }

    for (int i = optind; i < argc; ++i) {
        printf("non-option argument: %s\n", argv[i]);
    }

    return 0;
}

Build

From Developer Command Prompt for Visual Studio:

cl /Iinclude src\main.c src\getopt.c

Example execution:

main.exe -a -b hello file1 file2

option -a
option -b with argument: hello
non-option argument: file1
non-option argument: file2

3. Example Using `getopt_long()`

MinGW-w64's getopt.h also includes declarations for struct option, no_argument, required_argument, optional_argument, getopt_long(), and getopt_long_only(). (GitHub)

`main.c`

#include <stdio.h>
#include "getopt.h"

int main(int argc, char *argv[])
{
    static struct option long_options[] = {
        { "help",    no_argument,       0, 'h' },
        { "output",  required_argument, 0, 'o' },
        { "verbose", no_argument,       0, 'v' },
        { 0,         0,                 0,  0  }
    };

    int opt;
    int option_index = 0;

    while ((opt = getopt_long(argc, argv, "ho:v", long_options, &option_index)) != -1) {
        switch (opt) {
        case 'h':
            printf("help\n");
            break;

        case 'o':
            printf("output: %s\n", optarg);
            break;

        case 'v':
            printf("verbose\n");
            break;

        default:
            printf("usage: %s [--help] [--output file] [--verbose]\n", argv[0]);
            return 1;
        }
    }

    return 0;
}

Example Execution

main.exe --verbose --output result.txt

verbose
output: result.txt

4. Using It in a Visual Studio Project

For a .vcxproj project, configure it as follows.

File Layout

project/
  include/
    getopt.h
  src/
    getopt.c
    main.c

Settings

Item	Setting
C/C++ → General → Additional Include Directories	`$(ProjectDir)include`
Source Files	Add `getopt.c`
Linker	No special additional libraries required

If getopt.c is not added to the project, compilation may succeed but linking will fail. getopt.h only provides declarations; the actual definitions of getopt(), optind, and related symbols are contained in getopt.c. MinGW-w64's getopt.c provides definitions for optind, opterr, optopt, optarg, as well as implementations of getopt(), getopt_long(), and getopt_long_only(). (GitHub)

5. Do Not Mix MSYS2 Include/Lib Directories Directly into MSVC

Avoid configurations like:

C:\msys64\ucrt64\include
C:\msys64\ucrt64\lib

Adding these directories wholesale to MSVC include paths or library paths can mix MinGW-w64 headers and import libraries with MSVC's Windows SDK, UCRT, and CRT.

Problematic areas include:

Area	Issue
CRT headers	MSVC CRT and MinGW-w64 CRT have different assumptions
Windows headers	Windows SDK versions and MinGW-w64 versions may conflict
`.a` libraries	GCC-oriented import libraries differ from MSVC `.lib` files
ABI	C++ and runtime boundary incompatibilities can occur

Therefore, if you only want to use getopt with MSVC, it is better to copy getopt.h and getopt.c locally and compile them with MSVC rather than linking against the MSYS2 environment itself.

6. Licensing Considerations

`getopt.h`

MinGW-w64's getopt.h contains a disclaimer stating that no copyright has been assigned and that it has been placed in the Public Domain. (GitHub)

As a result, merely including getopt.h does not normally impose GPL/LGPL-style source disclosure obligations on your program.

`getopt.c`

The file requiring attention is getopt.c.

It contains at least the following license texts:

Origin	Nature
Todd C. Miller portions	Permissive license similar to ISC/BSD
NetBSD Foundation portions	BSD 2-clause style license

Both are permissive licenses and generally allow inclusion in commercial or closed-source products. However, the license terms require that copyright notices, conditions, and disclaimers be retained in source redistributions and reproduced in documentation or accompanying materials for binary redistributions. (GitHub)

Practical Compliance

When distributing binaries, provide something like:

THIRD-PARTY-NOTICES.txt
LICENSES/
  getopt.txt

For safety, place the license comment block from the beginning of getopt.c into getopt.txt verbatim.

7. What Happens to the License of Your Binary?

Even if getopt.h and getopt.c are statically compiled into your application using MSVC, your entire application does not become GPL or LGPL.

The practical situation is:

Item	Treatment
Your own source code	Any license you choose
`getopt.h`	Contains Public Domain disclaimer
`getopt.c`	Subject to permissive license conditions
Binary distribution	Include copyright notices, conditions, and disclaimers
Source disclosure obligation	Normally none
Commercial use	Normally allowed

The important point is that the requirement is generally a notice obligation, not a source disclosure obligation.

8. Recommended Distribution Layout

Whether commercial or non-commercial, the following structure is recommended:

dist/
  your_app.exe
  README.txt
  THIRD-PARTY-NOTICES.txt

Example THIRD-PARTY-NOTICES.txt:

This product includes getopt implementation derived from MinGW-w64 / OpenBSD / NetBSD sources.

The getopt.h file from MinGW-w64 states that it has no copyright assigned
and is placed in the Public Domain.

The getopt.c file contains permissive license notices from Todd C. Miller
and The NetBSD Foundation, Inc. The original copyright notices, permission
notice, conditions, and disclaimers are reproduced below.

[Paste the license comment block from the beginning of getopt.c here verbatim]

Even if your distribution is entirely in Japanese, it is safest to include the original English license text. If you add a translation, do not remove the original text.

9. Implementation Notes

Resetting `optind`

If getopt() needs to be run multiple times within the same process, optind must be reset:

optind = 1;

The MinGW-w64 implementation also supports BSD-style optreset, but for portability, using optind = 1 is generally preferable. getopt.h itself contains comments recommending that developers avoid relying on the non-standard BSD optreset for portability reasons. (GitHub)

Using from C++

getopt.h supports extern "C" and can therefore be used from C++ source files. (GitHub)

#include "getopt.h"

However, getopt.c should naturally be compiled as a C source file. In Visual Studio, leave its extension as .c when adding it to the project.

Separate Issue from `/utf-8` and Unicode

getopt() operates on narrow strings from main(int argc, char *argv[]).

If you need precise handling of Unicode command lines on Windows, consider using wmain(int argc, wchar_t *argv[]) or CommandLineToArgvW() instead.

getopt should be viewed as a POSIX-style parser for narrow-character argv.

10. Summary

When using getopt with MSVC, the safest approach is:

Copy getopt.h and getopt.c into your project.
Compile getopt.c as part of the project with MSVC.
Do not add MSYS2's /ucrt64/include or /ucrt64/lib directories wholesale to MSVC.
Treat getopt.h as having a Public Domain disclaimer.
Treat getopt.c as permissively licensed and include copyright notices, conditions, and disclaimers in distributed materials.
Your own binary normally incurs no source disclosure obligation, but you should provide appropriate third-party notices.

In practical terms, the key points for MSVC are: build getopt.c together with your project, not just the header, and preserve the license notices from getopt.c in distributed materials.

DEV Community: vast cow

How to Separate CUDA-Specific Code from Regular C++ Code

File Organization

CUDA-Side Implementation

Referencing CUDA Symbols from C++

Writing a Value to Constant Memory

Allocating Global Memory for Output

Launching the Kernel with cudaLaunchKernel

Preparing the Kernel Arguments

Launching the Kernel

Waiting for Kernel Completion

Copying the Result Back to the Host

Compiling

Purpose of This Structure

How to Automatically Switch Google Translate to Dark Theme

Main Purpose

Requirements

Installation

1. Install a User Script Extension

2. Create a New Script

3. Paste the Script

4. Save the Script

5. Open Google Translate

How to Use

Notes

Summary

Tampermonkey Script to Fix the Issue Where Long Album Titles Disappear in YouTube Music

What This Script Does

How to Use

How It Works

Summary

How to Use Windows Mobile Hotspot Without an Internet Connection

Purpose

How It Works

1. Change the Windows Connectivity Check Host to localhost

2. Start a Web Server for the Connectivity Check

Basic Usage

1. Run as Administrator

2. Make Sure Port 80 Is Available

3. Enable Mobile Hotspot

Behavior on Exit

Notes

Summary

Updating the Rocky Linux Version

Check the Current Version

Update Package Metadata

Update the Entire System

Reboot

Verify the Version

ELevate and Leapp Are Not Required

If You Have Pinned a Specific Minor Version

Display Order of GitHub Releases

Conclusion

Why Doesn't It Appear to Be Sorted by Date?

Is It Sorted by Tag Name?

Is It Sorted by Title?

Notes When Using the API

Practical Recommendations

Bookmarklet for Editing the Prompt Input Field in a Separate Window

Purpose

How to Use

Automatic Theme Switching

Loading the Current Value

Applying Edited Content

Cleanup

Notes

Launching an MSVC PowerShell

Purpose

How It Works

Command-Line Options

Starting the Script

Running Waydroid Inside Weston

Purpose

How to Use It

1. Start Weston

2. Start the Waydroid Session

3. Show the Waydroid Full UI

Stopping Waydroid

1. Shut Down Android Inside Waydroid

2. Stop the Waydroid Session

Launching the Kernel with `cudaLaunchKernel`

`main.c`

3. Example Using `getopt_long()`

`main.c`

`getopt.h`

`getopt.c`

Resetting `optind`

Separate Issue from `/utf-8` and Unicode