@simonklee/opentui-tex-native-source 0.2.0

package/LICENSE-PROJECT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenTUI Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @simonklee/opentui-tex-native-source
+
+Complete corresponding source for the statically linked native TeX renderer, including the patched ZigTeX and MicroTeX trees. Build a target with:
+
+```sh
+zig build -Doptimize=ReleaseSmall -Dtarget=<zig-target>
+```

package/build.zig

@@ -0,0 +1,112 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+const SupportedTarget = struct {
+    zig_target: []const u8,
+    output_name: []const u8,
+};
+
+// Keep this matrix aligned with OpenTUI's published native packages.
+const supported_targets = [_]SupportedTarget{
+    .{ .zig_target = "x86_64-linux-gnu.2.17", .output_name = "x86_64-linux" },
+    .{ .zig_target = "aarch64-linux-gnu.2.17", .output_name = "aarch64-linux" },
+    .{ .zig_target = "x86_64-linux-musl", .output_name = "x86_64-linux-musl" },
+    .{ .zig_target = "aarch64-linux-musl", .output_name = "aarch64-linux-musl" },
+    .{ .zig_target = "x86_64-macos.13.0", .output_name = "x86_64-macos" },
+    .{ .zig_target = "aarch64-macos.13.0", .output_name = "aarch64-macos" },
+    .{ .zig_target = "x86_64-windows-gnu", .output_name = "x86_64-windows" },
+    .{ .zig_target = "aarch64-windows-gnu", .output_name = "aarch64-windows" },
+};
+
+pub fn build(b: *std.Build) void {
+    const optimize = b.standardOptimizeOption(.{});
+    const target_option = b.option([]const u8, "target", "Build one supported Zig target");
+    const build_all = b.option(bool, "all", "Build all published native targets") orelse false;
+    addTests(b, optimize) catch @panic("failed to configure native tests");
+
+    if (target_option != null and build_all) {
+        std.debug.print("-Dtarget and -Dall cannot be used together\n", .{});
+        std.process.exit(1);
+    }
+
+    if (target_option) |target_name| {
+        for (supported_targets) |target| {
+            if (std.mem.eql(u8, target.zig_target, target_name)) {
+                addLibrary(b, target, optimize) catch @panic("failed to configure native target");
+                return;
+            }
+        }
+        std.debug.print("unsupported native target: {s}\n", .{target_name});
+        std.process.exit(1);
+    }
+
+    if (build_all) {
+        for (supported_targets) |target| {
+            addLibrary(b, target, optimize) catch @panic("failed to configure native target");
+        }
+        return;
+    }
+
+    const host_arch = @tagName(builtin.cpu.arch);
+    const host_os = @tagName(builtin.os.tag);
+    for (supported_targets) |target| {
+        if (std.mem.find(u8, target.zig_target, host_arch) != null and
+            std.mem.find(u8, target.zig_target, host_os) != null and
+            std.mem.find(u8, target.zig_target, "musl") == null)
+        {
+            addLibrary(b, target, optimize) catch @panic("failed to configure host target");
+            return;
+        }
+    }
+
+    std.debug.print("unsupported host: {s}-{s}\n", .{ host_arch, host_os });
+    std.process.exit(1);
+}
+
+fn addTests(b: *std.Build, optimize: std.builtin.OptimizeMode) !void {
+    const test_target = if (builtin.os.tag == .linux)
+        try std.Target.Query.parse(.{ .arch_os_abi = try std.fmt.allocPrint(b.allocator, "{s}-linux-musl", .{@tagName(builtin.cpu.arch)}) })
+    else
+        std.Target.Query{};
+    const target = b.resolveTargetQuery(test_target);
+    const module = nativeModule(b, target, optimize);
+    const tests = b.addTest(.{ .root_module = module });
+    const run_tests = b.addRunArtifact(tests);
+    b.step("test", "Run native renderer tests").dependOn(&run_tests.step);
+}
+
+fn addLibrary(
+    b: *std.Build,
+    supported_target: SupportedTarget,
+    optimize: std.builtin.OptimizeMode,
+) !void {
+    const query = try std.Target.Query.parse(.{ .arch_os_abi = supported_target.zig_target });
+    const target = b.resolveTargetQuery(query);
+    const module = nativeModule(b, target, optimize);
+
+    const library = b.addLibrary(.{
+        .name = "tex_renderer",
+        .linkage = .dynamic,
+        .root_module = module,
+    });
+    const install = b.addInstallArtifact(library, .{
+        .dest_dir = .{ .override = .{
+            .custom = try std.fmt.allocPrint(b.allocator, "lib/{s}", .{supported_target.output_name}),
+        } },
+    });
+    b.getInstallStep().dependOn(&install.step);
+}
+
+fn nativeModule(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) *std.Build.Module {
+    const zigtex = b.dependency("zigtex", .{ .target = target, .optimize = optimize });
+    const module = b.createModule(.{
+        .root_source_file = b.path("native/lib.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    module.addImport("zigtex", zigtex.module("zigtex"));
+    module.addIncludePath(b.path("native/vendor"));
+    module.addCSourceFile(.{ .file = b.path("native/nanosvg.c"), .flags = &.{"-std=c99"} });
+    module.link_libc = true;
+    return module;
+}

package/build.zig.zon

@@ -0,0 +1,12 @@
+.{
+    .name = .latex_renderer,
+    .fingerprint = 0x7ef7d1d7f7d59666,
+    .version = "0.1.0",
+    .minimum_zig_version = "0.16.0",
+    .dependencies = .{
+        .zigtex = .{
+            .path = "native/vendor/zigtex",
+        },
+    },
+    .paths = .{ "build.zig", "build.zig.zon", "native" },
+}

package/native/lib.zig

@@ -0,0 +1,280 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const zigtex = @import("zigtex");
+
+const c = @cImport({
+    @cInclude("nanosvg.h");
+    @cInclude("nanosvgrast.h");
+});
+
+const source_size_max = 4096;
+const dimension_max = 4096;
+const supersample = 4;
+const channels = 4;
+
+const Status = enum(u32) {
+    ok = 0,
+    invalid_argument = 1,
+    invalid_tex = 2,
+    invalid_svg = 3,
+    invalid_dimensions = 4,
+    out_of_memory = 5,
+    internal_error = 6,
+};
+
+const RenderResult = struct {
+    pixels: []u8 = &.{},
+    width: u32 = 0,
+    height: u32 = 0,
+    status: Status = .ok,
+};
+
+var renderer_instance: ?zigtex.TexSvgRender = null;
+var test_fail_after_pixel_allocation = false;
+var test_pixel_allocations: usize = 0;
+
+export fn texInit() u32 {
+    if (renderer_instance != null) return @intFromEnum(Status.ok);
+    renderer_instance = zigtex.TexSvgRender.init(std.heap.c_allocator, .{}) catch |err| {
+        return @intFromEnum(statusFromError(err));
+    };
+    return @intFromEnum(Status.ok);
+}
+
+export fn texRender(
+    source_ptr: ?[*]const u8,
+    source_length: u32,
+    display_value: u8,
+    foreground_ptr: ?[*]const u8,
+    background_ptr: ?[*]const u8,
+) ?*RenderResult {
+    const result = std.heap.c_allocator.create(RenderResult) catch return null;
+    result.* = .{};
+
+    if (source_ptr == null or source_length == 0 or source_length > source_size_max) {
+        result.status = .invalid_argument;
+        return result;
+    }
+    if (foreground_ptr == null or background_ptr == null) {
+        result.status = .invalid_argument;
+        return result;
+    }
+
+    const source = source_ptr.?[0..source_length];
+    const foreground = foreground_ptr.?[0..3].*;
+    const background = background_ptr.?[0..3].*;
+
+    if (renderer_instance == null) {
+        result.status = .internal_error;
+        return result;
+    }
+    if (display_value > 1) {
+        result.status = .invalid_argument;
+        return result;
+    }
+    render(result, source, display_value == 1, foreground, background) catch |err| {
+        result.status = statusFromError(err);
+    };
+    return result;
+}
+
+export fn texResultStatus(result: ?*const RenderResult) u32 {
+    return if (result) |value| @intFromEnum(value.status) else @intFromEnum(Status.invalid_argument);
+}
+
+export fn texResultPixels(result: ?*const RenderResult) ?[*]const u8 {
+    const value = result orelse return null;
+    return if (value.pixels.len == 0) null else value.pixels.ptr;
+}
+
+export fn texResultPixelsLength(result: ?*const RenderResult) u32 {
+    const value = result orelse return 0;
+    const pixel_count = std.math.mul(u32, value.width, value.height) catch return 0;
+    return std.math.mul(u32, pixel_count, channels) catch 0;
+}
+
+export fn texResultWidth(result: ?*const RenderResult) u32 {
+    return if (result) |value| value.width else 0;
+}
+
+export fn texResultHeight(result: ?*const RenderResult) u32 {
+    return if (result) |value| value.height else 0;
+}
+
+export fn texResultDestroy(result: ?*RenderResult) void {
+    const value = result orelse return;
+    freeResultPixels(value.pixels);
+    std.heap.c_allocator.destroy(value);
+}
+
+fn render(
+    result: *RenderResult,
+    source: []const u8,
+    display: bool,
+    foreground: [3]u8,
+    background: [3]u8,
+) !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.c_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var foreground_buffer: [7]u8 = undefined;
+    const foreground_css = try std.fmt.bufPrint(
+        &foreground_buffer,
+        "#{x:0>2}{x:0>2}{x:0>2}",
+        .{ foreground[0], foreground[1], foreground[2] },
+    );
+    const renderer = &(renderer_instance orelse return error.InternalError);
+    const svg = renderer.parseRender(allocator, source, .{
+        .size = 28,
+        .spacing = 8,
+        .style = if (display) .display else .in_line,
+        .x_pad = 3,
+        .y_pad = 3,
+        .default_color = foreground_css,
+    }) catch return error.InvalidTex;
+
+    const mutable_svg = try svgWithoutDescription(allocator, svg);
+    const image = c.nsvgParse(mutable_svg.ptr, "px", 96) orelse return error.InvalidSvg;
+    defer c.nsvgDelete(image);
+    const width: usize = @intFromFloat(@ceil(image.*.width * supersample));
+    const height: usize = @intFromFloat(@ceil(image.*.height * supersample));
+    if (width == 0 or height == 0 or width > dimension_max or height > dimension_max) {
+        return error.InvalidDimensions;
+    }
+    const pixel_length = std.math.mul(usize, width, height) catch return error.InvalidDimensions;
+    const pixels_length = std.math.mul(usize, pixel_length, channels) catch return error.InvalidDimensions;
+    if (pixels_length > std.math.maxInt(u32)) return error.InvalidDimensions;
+    const pixels = try allocResultPixels(pixels_length);
+    errdefer freeResultPixels(pixels);
+    if (builtin.is_test and test_fail_after_pixel_allocation) return error.OutOfMemory;
+    const rasterizer = c.nsvgCreateRasterizer() orelse return error.OutOfMemory;
+    defer c.nsvgDeleteRasterizer(rasterizer);
+    c.nsvgRasterize(
+        rasterizer,
+        image,
+        0,
+        0,
+        supersample,
+        pixels.ptr,
+        @intCast(width),
+        @intCast(height),
+        @intCast(width * channels),
+    );
+    compositeBackground(pixels, background);
+
+    result.pixels = pixels;
+    result.width = @intCast(width);
+    result.height = @intCast(height);
+}
+
+fn allocResultPixels(length: usize) ![]u8 {
+    const pixels = try std.heap.c_allocator.alloc(u8, length);
+    if (builtin.is_test) test_pixel_allocations += 1;
+    return pixels;
+}
+
+fn freeResultPixels(pixels: []u8) void {
+    if (pixels.len == 0) return;
+    std.heap.c_allocator.free(pixels);
+    if (builtin.is_test) {
+        std.debug.assert(test_pixel_allocations > 0);
+        test_pixel_allocations -= 1;
+    }
+}
+
+fn statusFromError(err: anyerror) Status {
+    return switch (err) {
+        error.InvalidTex => .invalid_tex,
+        error.InvalidSvg => .invalid_svg,
+        error.InvalidDimensions => .invalid_dimensions,
+        error.OutOfMemory => .out_of_memory,
+        else => .internal_error,
+    };
+}
+
+fn compositeBackground(pixels: []u8, background: [3]u8) void {
+    var offset: usize = 0;
+    while (offset < pixels.len) : (offset += channels) {
+        const alpha: u16 = pixels[offset + 3];
+        const inverse = 255 - alpha;
+        inline for (0..3) |channel| {
+            pixels[offset + channel] = @intCast(
+                (@as(u16, pixels[offset + channel]) * alpha +
+                    @as(u16, background[channel]) * inverse + 127) / 255,
+            );
+        }
+        pixels[offset + 3] = 255;
+    }
+}
+
+fn svgWithoutDescription(allocator: std.mem.Allocator, svg: []const u8) ![:0]u8 {
+    const start = std.mem.indexOf(u8, svg, "<desc>") orelse return allocator.dupeZ(u8, svg);
+    const close = std.mem.lastIndexOf(u8, svg, "</desc>") orelse return error.InvalidSvg;
+    if (close < start) return error.InvalidSvg;
+    var cleaned = try std.ArrayList(u8).initCapacity(allocator, svg.len - (close + 7 - start));
+    defer cleaned.deinit(allocator);
+    try cleaned.appendSlice(allocator, svg[0..start]);
+    try cleaned.appendSlice(allocator, svg[close + 7 ..]);
+    return allocator.dupeZ(u8, cleaned.items);
+}
+
+fn renderForTest(source: []const u8, foreground: *const [3]u8, background: *const [3]u8) !*RenderResult {
+    if (texInit() != @intFromEnum(Status.ok)) return error.InitializationFailed;
+    return texRender(source.ptr, @intCast(source.len), 0, foreground, background) orelse error.OutOfMemory;
+}
+
+test "render result contains bounded opaque RGBA pixels" {
+    const foreground = [3]u8{ 255, 255, 255 };
+    const background = [3]u8{ 1, 2, 3 };
+    const result = try renderForTest("x", &foreground, &background);
+    defer texResultDestroy(result);
+
+    try std.testing.expectEqual(@as(u32, @intFromEnum(Status.ok)), texResultStatus(result));
+    try std.testing.expect(result.width > 0 and result.width <= dimension_max);
+    try std.testing.expect(result.height > 0 and result.height <= dimension_max);
+    const expected_length = result.width * result.height * channels;
+    try std.testing.expectEqual(expected_length, texResultPixelsLength(result));
+    try std.testing.expectEqual(@as(usize, expected_length), result.pixels.len);
+    try std.testing.expect(texResultPixels(result) != null);
+
+    var contains_foreground = false;
+    var offset: usize = 0;
+    while (offset < result.pixels.len) : (offset += channels) {
+        try std.testing.expectEqual(@as(u8, 255), result.pixels[offset + 3]);
+        contains_foreground = contains_foreground or !std.mem.eql(u8, result.pixels[offset .. offset + 3], &background);
+    }
+    try std.testing.expect(contains_foreground);
+}
+
+test "texResultDestroy frees successful result pixels" {
+    const foreground = [3]u8{ 255, 255, 255 };
+    const background = [3]u8{ 0, 0, 0 };
+    const allocations_before = test_pixel_allocations;
+    const result = try renderForTest("y", &foreground, &background);
+    try std.testing.expectEqual(allocations_before + 1, test_pixel_allocations);
+    texResultDestroy(result);
+    try std.testing.expectEqual(allocations_before, test_pixel_allocations);
+}
+
+test "render frees result pixels after a partial failure" {
+    const foreground = [3]u8{ 255, 255, 255 };
+    const background = [3]u8{ 0, 0, 0 };
+    const allocations_before = test_pixel_allocations;
+    test_fail_after_pixel_allocation = true;
+    defer test_fail_after_pixel_allocation = false;
+    const result = try renderForTest("z", &foreground, &background);
+    defer texResultDestroy(result);
+
+    try std.testing.expectEqual(@as(u32, @intFromEnum(Status.out_of_memory)), texResultStatus(result));
+    try std.testing.expectEqual(allocations_before, test_pixel_allocations);
+    try std.testing.expectEqual(@as(u32, 0), texResultPixelsLength(result));
+    try std.testing.expect(texResultPixels(result) == null);
+}
+
+test "maximum result dimensions and ABI pixel length are bounded" {
+    try std.testing.expect(dimension_max <= std.math.maxInt(u32));
+    const pixel_count_max = try std.math.mul(u32, dimension_max, dimension_max);
+    const pixel_length_max = try std.math.mul(u32, pixel_count_max, channels);
+    try std.testing.expect(pixel_length_max <= std.math.maxInt(u32));
+}

package/native/nanosvg.c

@@ -0,0 +1,4 @@
+#define NANOSVG_IMPLEMENTATION
+#define NANOSVGRAST_IMPLEMENTATION
+#include "nanosvg.h"
+#include "nanosvgrast.h"

package/native/vendor/.bootstrap-v5

@@ -0,0 +1 @@
+zigtex=fda2819e45f57ca2071810c47249a46bfc782cdf microtex=74e8fee9e47edc3a777e64fb2eff9a85a01defac nanosvg=239e102ec2c691f2902e20ace2ed36ee4a35cfe6 zig=0.16-v5

package/native/vendor/LICENSE-NANOSVG

@@ -0,0 +1,18 @@
+Copyright (c) 2013-14 Mikko Mononen memon@inside.org
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+

package/native/vendor/microtex/.clang-format

@@ -0,0 +1,26 @@
+BasedOnStyle: Google
+ColumnLimit: 100
+IndentWidth: 2
+ContinuationIndentWidth: 2
+AccessModifierOffset: -2
+
+AllowShortBlocksOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Inline
+
+AlignAfterOpenBracket: BlockIndent
+BinPackArguments: false
+BinPackParameters: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowAllArgumentsOnNextLine: false
+ReflowComments: true
+
+AlignTrailingComments: true
+BreakBeforeBinaryOperators: NonAssignment
+
+AlignArrayOfStructures: Left
+
+PenaltyBreakAssignment: 20
+PenaltyBreakBeforeFirstCallParameter: 0

package/native/vendor/microtex/.github/workflows/ubuntu.yml

@@ -0,0 +1,92 @@
+name: Ubuntu
+
+on:
+  - pull_request
+
+jobs:
+  build_by_meson:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          - ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Downloading dependencies 📥
+        run: |
+          sudo apt-get install build-essential meson libgtksourceviewmm-3.0-dev libgtkmm-3.0-dev libgtk-4-dev libgtksourceview-5-dev gi-docgen
+          sudo apt-get install qtbase5-dev qttools5-dev-tools
+      - name: Configure 🔧
+        run: meson _build -DTARGET_DOCUMENTATION=true
+      - name: Compile 🎲
+        run: ninja -C _build
+      - name: Compress build artifacts 📦
+        run: |
+          pushd _build
+          tar -c * | zstd -o $GITHUB_WORKSPACE/artifacts.tar.zst
+          popd
+      - name: Upload build artifacts 📤
+        uses: actions/upload-artifact@v1
+        with:
+          name: Build artifacts
+          path: artifacts.tar.zst
+
+  build_by_cmake:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          - ubuntu-22.04
+    steps:
+      - name: Downloading Source Code 📥
+        uses: actions/checkout@v2
+      - name: Downloading dependencies 📥
+        run: |
+          sudo apt-get install build-essential meson libgtksourceviewmm-3.0-dev libgtkmm-3.0-dev libgtk-4-dev libgtksourceview-5-dev
+          sudo apt-get install qtbase5-dev qttools5-dev-tools
+      - name: Configure 🔧
+        run: |
+          cd ${{ github.workspace }}
+          mkdir build
+          cd build
+          cmake .. -DCMAKE_BUILD_TYPE=Release -DHAVE_AUTO_FONT_FIND=ON -DCAIRO=ON -DBUILD_EXAMPLE_GTKMM=ON -DGTK=ON -DBUILD_EXAMPLE_GTK=ON -DQT=ON -DBUILD_EXAMPLE_QT=ON -DBUILD_EXAMPLE_QTPNG=ON -DBUILD_EXAMPLE_MEMCHECK=ON -DWASM=OFF -DHAVE_LOG=ON -G Ninja
+      - name: Compile 🎲
+        run: |
+          cd ${{ github.workspace }}
+          cd build
+          ninja
+
+  build_wasm:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          - ubuntu-20.04
+    steps:
+      - name: Downloading Source Code 📥
+        uses: actions/checkout@v2
+      - name: Downloading dependencies 📥
+        run: |
+          sudo apt-get install ninja-build
+          sudo pip3 install meson # meson provided by ubuntu is too old. can be removed when ubunut-latest swiches to 24.04
+      - name: Setup Emscripten Environment 🍺
+        uses: mymindstorm/setup-emsdk@v11
+      - name: Verify Emscripten 🚀
+        run: emcc -v
+      - name: Compile using CMake 🎲
+        run: |
+          cd ${{ github.workspace }}
+          cd platform/wasm/web
+          npm install
+          npm run build:lib && npm run build:example
+      - name: Compile using Meson 🎲
+        run: |
+          cd ${{ github.workspace }}
+          cd platform/wasm/web
+          npm install
+          npm run build:lib:meson && npm run build:example:meson
+      - name: Upload build artifacts 📤
+        uses: actions/upload-artifact@v1
+        with:
+          name: MicroTeX wasm example
+          path: platform/wasm/web/example-dist

package/native/vendor/microtex/.github/workflows/windows-gdi.yml

@@ -0,0 +1,34 @@
+name: Windows GDI+
+
+on:
+  - pull_request
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          - windows-2019
+    steps:
+    - name: Downloading Source Code 📥
+      uses: actions/checkout@v2
+    - name: Downloading CMake 📥
+      # Install latest CMake.
+      uses: lukka/get-cmake@latest
+    - name: Setup Environment (x64)
+      uses: ilammy/msvc-dev-cmd@v1
+      if: runner.os == 'Windows'
+      with:
+        arch: x64
+    - name: Configure 🔧
+      run: |
+        cd ${{ github.workspace }}
+        mkdir build -force
+        cd build
+        cmake .. -DCMAKE_BUILD_TYPE=Release -DHAVE_AUTO_FONT_FIND=OFF -DGDI=ON -DBUILD_EXAMPLE_WIN32=ON -G Ninja
+    - name: Compile 🎲
+      run: |
+        cd ${{ github.workspace }}
+        cd build
+        ninja

package/native/vendor/microtex/.github/workflows/windows-qt.yml

@@ -0,0 +1,52 @@
+name: Windows Qt
+
+on: 
+  - pull_request
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix: 
+        os: 
+          - windows-2019
+        include:
+          - qt_ver: 5.15.2
+            qt_arch: win64_msvc2019_64
+            msvc_arch: x64
+            qt_arch_install: msvc2019_64
+          - qt_ver: 6.0.0
+            qt_arch: win64_msvc2019_64
+            msvc_arch: x64
+            qt_arch_install: msvc2019_64
+    steps:
+    - name: Downloading Source Code 📥
+      uses: actions/checkout@v2
+    - name: Downloading CMake 📥
+      # Install latest CMake.
+      uses: lukka/get-cmake@latest
+    - name: Setup Environment (x64)
+      uses: ilammy/msvc-dev-cmd@v1
+      if: runner.os == 'Windows'
+      with:
+        arch: x64
+    - name: Downloading Qt 📥
+      uses: jurplel/install-qt-action@v2.13.0
+      with:
+          # Version of Qt to install
+        version: ${{ matrix.qt_ver }}
+          # Target platform for build
+          # target: ${{ matrix.qt_target }}
+        arch: ${{ matrix.qt_arch }}
+        cached: 'false'
+    - name: Configure 🔧
+      run: |
+        cd ${{ github.workspace }}
+        mkdir build -force
+        cd build
+        cmake .. -DHAVE_AUTO_FONT_FIND=OFF -DQT=ON -DBUILD_EXAMPLE_QT=ON -DCMAKE_BUILD_TYPE=Release -G Ninja
+    - name: Compile 🎲
+      run: |
+        cd ${{ github.workspace }}
+        cd build
+        ninja