imxc 0.5.4 → 0.6.1

package/dist/templates/filedialog.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/filedialog.js

@@ -0,0 +1,216 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { registerTemplate, buildImxDts, TSCONFIG, GITIGNORE, cmakeTemplate } from './index.js';
+const APPSTATE_INTERFACE = `interface AppState {
+    filePath: string;
+    message: string;
+    onOpen: () => void;
+    onSave: () => void;
+}`;
+const APPSTATE_H = `#pragma once
+#include <string>
+#include <functional>
+
+struct AppState {
+    std::string filePath = "";
+    std::string message = "";
+    std::function<void()> onOpen;
+    std::function<void()> onSave;
+};
+`;
+const MAIN_CPP = `#include <imx/runtime.h>
+#include <imx/renderer.h>
+#include <imx/pfd.h>
+
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <GLFW/glfw3.h>
+
+#include "AppState.h"
+
+struct App {
+    GLFWwindow*      window  = nullptr;
+    ImGuiIO*         io      = nullptr;
+    imx::Runtime runtime;
+    AppState state;
+};
+
+static void render_frame(App& app) {
+    glfwMakeContextCurrent(app.window);
+    if (glfwGetWindowAttrib(app.window, GLFW_ICONIFIED) != 0) return;
+
+    int fb_w = 0, fb_h = 0;
+    glfwGetFramebufferSize(app.window, &fb_w, &fb_h);
+    if (fb_w <= 0 || fb_h <= 0) return;
+
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    ImGui::NewFrame();
+
+    imx::render_root(app.runtime, app.state);
+
+    ImGui::Render();
+    glViewport(0, 0, fb_w, fb_h);
+    glClearColor(0.12F, 0.12F, 0.15F, 1.0F);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    if ((app.io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != 0) {
+        ImGui::UpdatePlatformWindows();
+        ImGui::RenderPlatformWindowsDefault();
+    }
+
+    glfwMakeContextCurrent(app.window);
+    glfwSwapBuffers(app.window);
+}
+
+static void window_size_callback(GLFWwindow* window, int, int) {
+    auto* app = static_cast<App*>(glfwGetWindowUserPointer(window));
+    if (app) render_frame(*app);
+}
+
+int main() {
+    if (glfwInit() == 0) return 1;
+
+    const char* glsl_version = "#version 150";
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    GLFWwindow* window = glfwCreateWindow(800, 600, "APP_NAME", nullptr, nullptr);
+    if (!window) { glfwTerminate(); return 1; }
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+
+    ImGui::StyleColorsDark();
+    ImGuiStyle& style = ImGui::GetStyle();
+    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
+        style.WindowRounding = 0.0F;
+        style.Colors[ImGuiCol_WindowBg].w = 1.0F;
+    }
+
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+    ImGui_ImplOpenGL3_Init(glsl_version);
+
+    App app;
+    app.window = window;
+    app.io = &io;
+    glfwSetWindowUserPointer(window, &app);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+
+    app.state.onOpen = [&]() {
+        auto result = pfd::open_file("Open File").result();
+        if (!result.empty()) {
+            app.state.filePath = result[0];
+            app.state.message = "Opened: " + result[0];
+            app.runtime.request_frame();
+        }
+    };
+
+    app.state.onSave = [&]() {
+        auto result = pfd::save_file("Save File").result();
+        if (!result.empty()) {
+            app.state.filePath = result;
+            app.state.message = "Save to: " + result;
+            app.runtime.request_frame();
+        }
+    };
+
+    // GLFW file drop callback
+    glfwSetDropCallback(window, [](GLFWwindow* w, int count, const char** paths) {
+        auto* a = static_cast<App*>(glfwGetWindowUserPointer(w));
+        if (a && count > 0) {
+            a->state.filePath = paths[0];
+            a->state.message = "Dropped: " + std::string(paths[0]);
+            a->runtime.request_frame();
+        }
+    });
+
+    while (glfwWindowShouldClose(window) == 0) {
+        if (app.runtime.needs_frame()) {
+            glfwPollEvents();
+        } else {
+            glfwWaitEventsTimeout(0.1);
+        }
+        render_frame(app);
+        app.runtime.frame_rendered(ImGui::IsAnyItemActive());
+    }
+
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}
+
+#ifdef _WIN32
+#include <windows.h>
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { return main(); }
+#endif
+`;
+const APP_TSX = `export default function App(props: AppState) {
+  return (
+    <DockSpace>
+      <Window title="File Dialog Demo">
+        <Column gap={8}>
+          <Text>Native File Dialogs + Drag & Drop</Text>
+          <Separator />
+          <Row gap={8}>
+            <Button title="Open File" onPress={props.onOpen} />
+            <Button title="Save File" onPress={props.onSave} />
+          </Row>
+          <Text>Drag & drop a file onto this window</Text>
+          {props.message !== "" && <Text color={[0, 1, 0, 1]}>{props.message}</Text>}
+          {props.filePath !== "" && <Text>Path: {props.filePath}</Text>}
+        </Column>
+      </Window>
+    </DockSpace>
+  );
+}
+`;
+function generate(projectDir, projectName) {
+    const srcDir = path.join(projectDir, 'src');
+    if (fs.existsSync(path.join(srcDir, 'App.tsx'))) {
+        console.error(`Error: ${srcDir}/App.tsx already exists. Aborting.`);
+        process.exit(1);
+    }
+    fs.mkdirSync(srcDir, { recursive: true });
+    const publicDir = path.join(projectDir, 'public');
+    fs.mkdirSync(publicDir, { recursive: true });
+    // Write files
+    fs.writeFileSync(path.join(srcDir, 'main.cpp'), MAIN_CPP.replace('APP_NAME', projectName));
+    fs.writeFileSync(path.join(srcDir, 'AppState.h'), APPSTATE_H);
+    fs.writeFileSync(path.join(srcDir, 'App.tsx'), APP_TSX);
+    fs.writeFileSync(path.join(srcDir, 'imx.d.ts'), buildImxDts(APPSTATE_INTERFACE));
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), TSCONFIG);
+    fs.writeFileSync(path.join(projectDir, 'CMakeLists.txt'), cmakeTemplate(projectName, 'https://github.com/bgocumlu/imx.git'));
+    fs.writeFileSync(path.join(projectDir, '.gitignore'), GITIGNORE);
+    console.log(`imxc: initialized project "${projectName}" with template "filedialog"`);
+    console.log('');
+    console.log('  Created:');
+    console.log(`    src/main.cpp          — app shell with pfd + GLFW drop callback`);
+    console.log(`    src/AppState.h        — C++ state struct with filePath/message fields`);
+    console.log(`    src/App.tsx           — your root component`);
+    console.log(`    src/imx.d.ts          — type definitions for IDE support`);
+    console.log(`    tsconfig.json         — TypeScript config`);
+    console.log(`    CMakeLists.txt        — build config with FetchContent`);
+    console.log(`    .gitignore            — ignores build/, node_modules/, *.ini`);
+    console.log(`    public/               — static assets (copied to exe directory)`);
+    console.log('');
+    console.log('  Next steps:');
+    console.log(`    cd ${projectName}`);
+    console.log(`    cmake -B build`);
+    console.log(`    cmake --build build`);
+}
+registerTemplate({ name: 'filedialog', description: 'Native file dialogs + drag & drop', generate });

package/dist/templates/hotreload.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/hotreload.js

@@ -0,0 +1,400 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { registerTemplate, buildImxDts, TSCONFIG, GITIGNORE } from './index.js';
+const APPSTATE_INTERFACE = `interface AppState {
+    count: number;
+    speed: number;
+    watchCmd: string;
+    onIncrement: () => void;
+    onCopyCmd: () => void;
+}`;
+const APPSTATE_H = `#pragma once
+#include <string>
+#include <functional>
+
+struct AppState {
+    int count = 0;
+    float speed = 5.0F;
+    std::string watchCmd;
+    std::function<void()> onIncrement;
+    std::function<void()> onCopyCmd;
+};
+`;
+const HOTRELOAD_H = `#pragma once
+#include <string>
+#include <filesystem>
+#include <iostream>
+#include <imx/runtime.h>
+#include <imgui.h>
+#include "AppState.h"
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#include <unistd.h>
+#endif
+
+struct HotModule {
+    using RenderFn = void(*)(imx::Runtime&, AppState&, ImGuiContext*);
+
+#ifdef _WIN32
+    HMODULE handle = nullptr;
+#else
+    void* handle = nullptr;
+#endif
+    RenderFn render = nullptr;
+    std::filesystem::file_time_type last_write{};
+    std::string path;
+
+    bool load(const std::string& lib_path) {
+        path = lib_path;
+        if (!std::filesystem::exists(path)) {
+            std::cerr << "hotreload: " << path << " not found\\n";
+            return false;
+        }
+        last_write = std::filesystem::last_write_time(path);
+
+#ifdef _WIN32
+        // Copy DLL to avoid locking the original (allows rebuild while loaded)
+        std::string copy_path = path + ".live";
+        std::filesystem::copy_file(path, copy_path, std::filesystem::copy_options::overwrite_existing);
+        handle = LoadLibraryA(copy_path.c_str());
+        if (!handle) {
+            std::cerr << "hotreload: LoadLibrary failed\\n";
+            return false;
+        }
+        render = reinterpret_cast<RenderFn>(GetProcAddress(handle, "imx_render"));
+#else
+        handle = dlopen(path.c_str(), RTLD_NOW);
+        if (!handle) {
+            std::cerr << "hotreload: dlopen failed: " << dlerror() << "\\n";
+            return false;
+        }
+        render = reinterpret_cast<RenderFn>(dlsym(handle, "imx_render"));
+#endif
+        if (!render) {
+            std::cerr << "hotreload: imx_render symbol not found\\n";
+            unload();
+            return false;
+        }
+        std::cout << "hotreload: loaded " << path << "\\n";
+        return true;
+    }
+
+    void unload() {
+        if (!handle) return;
+#ifdef _WIN32
+        FreeLibrary(handle);
+#else
+        dlclose(handle);
+#endif
+        handle = nullptr;
+        render = nullptr;
+    }
+
+    bool check_reload() {
+        if (path.empty() || !std::filesystem::exists(path)) return false;
+        auto current = std::filesystem::last_write_time(path);
+        if (current == last_write) return false;
+        std::cout << "hotreload: change detected, reloading...\\n";
+        unload();
+        // Small delay to ensure file write is complete
+#ifdef _WIN32
+        Sleep(100);
+#else
+        usleep(100000);
+#endif
+        if (load(path)) {
+            std::cout << "hotreload: reload successful\\n";
+            return true;
+        }
+        std::cerr << "hotreload: reload failed\\n";
+        return false;
+    }
+
+    ~HotModule() { unload(); }
+};
+`;
+const UI_ENTRY_CPP = `#include <imx/runtime.h>
+#include <imgui.h>
+#include "AppState.h"
+
+// Declared in app_root.gen.cpp (generated by imxc)
+namespace imx {
+template <> void render_root<AppState>(imx::Runtime& runtime, AppState& state);
+}
+
+#ifdef _WIN32
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT __attribute__((visibility("default")))
+#endif
+
+// ImGuiContext* must be passed from host — DLL has its own static ImGui globals
+extern "C" EXPORT void imx_render(imx::Runtime& runtime, AppState& state, ImGuiContext* ctx) {
+    ImGui::SetCurrentContext(ctx);
+    imx::render_root(runtime, state);
+}
+`;
+const MAIN_CPP = `#include <imx/runtime.h>
+#include <imx/renderer.h>
+
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <GLFW/glfw3.h>
+
+#include "hotreload.h"
+#include "AppState.h"
+
+struct App {
+    GLFWwindow*  window  = nullptr;
+    ImGuiIO*     io      = nullptr;
+    imx::Runtime runtime;
+    AppState     state;
+    HotModule    module;
+};
+
+static void render_frame(App& app) {
+    glfwMakeContextCurrent(app.window);
+    if (glfwGetWindowAttrib(app.window, GLFW_ICONIFIED) != 0) return;
+
+    int fb_w = 0, fb_h = 0;
+    glfwGetFramebufferSize(app.window, &fb_w, &fb_h);
+    if (fb_w <= 0 || fb_h <= 0) return;
+
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    ImGui::NewFrame();
+
+    app.module.check_reload();
+    if (app.module.render) {
+        app.module.render(app.runtime, app.state, ImGui::GetCurrentContext());
+    }
+
+    ImGui::Render();
+    glViewport(0, 0, fb_w, fb_h);
+    glClearColor(0.12F, 0.12F, 0.15F, 1.0F);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    if ((app.io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != 0) {
+        ImGui::UpdatePlatformWindows();
+        ImGui::RenderPlatformWindowsDefault();
+    }
+
+    glfwMakeContextCurrent(app.window);
+    glfwSwapBuffers(app.window);
+}
+
+static void window_size_callback(GLFWwindow* window, int, int) {
+    auto* app = static_cast<App*>(glfwGetWindowUserPointer(window));
+    if (app) render_frame(*app);
+}
+
+int main() {
+    if (glfwInit() == 0) return 1;
+
+    const char* glsl_version = "#version 150";
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    GLFWwindow* window = glfwCreateWindow(1000, 700, "APP_NAME", nullptr, nullptr);
+    if (!window) { glfwTerminate(); return 1; }
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+
+    ImGui::StyleColorsDark();
+    ImGuiStyle& style = ImGui::GetStyle();
+    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
+        style.WindowRounding = 0.0F;
+        style.Colors[ImGuiCol_WindowBg].w = 1.0F;
+    }
+
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+    ImGui_ImplOpenGL3_Init(glsl_version);
+
+    App app;
+    app.window = window;
+    app.io = &io;
+    glfwSetWindowUserPointer(window, &app);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+
+    app.state.onIncrement = [&]() { app.state.count++; };
+    app.state.watchCmd = "npx imxc watch src -o build/generated --build \\"cmake --build build --target imx_ui\\"";
+    app.state.onCopyCmd = [&]() { imx::clipboard_set(app.state.watchCmd.c_str()); };
+
+#ifdef _WIN32
+    app.module.load("imx_ui.dll");
+#elif defined(__APPLE__)
+    app.module.load("libimx_ui.dylib");
+#else
+    app.module.load("libimx_ui.so");
+#endif
+
+    while (glfwWindowShouldClose(window) == 0) {
+        if (app.runtime.needs_frame()) {
+            glfwPollEvents();
+        } else {
+            glfwWaitEventsTimeout(0.1);
+        }
+        render_frame(app);
+        app.runtime.frame_rendered(ImGui::IsAnyItemActive());
+    }
+
+    app.module.unload();
+
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}
+
+#ifdef _WIN32
+#include <windows.h>
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { return main(); }
+#endif
+`;
+const APP_TSX = `export default function App(props: AppState) {
+  const [showAbout, setShowAbout] = useState(false);
+
+  return (
+    <DockSpace>
+      <Window title="Controls">
+        <Column gap={8}>
+          <Text>Count: {props.count}</Text>
+          <Button title="Increment" onPress={props.onIncrement} />
+          <SliderFloat label="Speed" value={props.speed} min={0} max={100} />
+          <Separator />
+          <Button title="About" onPress={() => setShowAbout(!showAbout)} />
+        </Column>
+      </Window>
+      <Window title="Hot Reload">
+        <Column gap={8}>
+          <Text>Run this in a second terminal to enable live reload:</Text>
+          <Text wrapped={true}>{props.watchCmd}</Text>
+          <Button title="Copy" onPress={props.onCopyCmd} />
+        </Column>
+      </Window>
+      {showAbout && <Window title="About">
+        <Text>Built with IMX (hot-reloadable!)</Text>
+        <Button title="Close" onPress={() => setShowAbout(false)} />
+      </Window>}
+    </DockSpace>
+  );
+}
+`;
+function cmakeHotreload(projectName) {
+    return `cmake_minimum_required(VERSION 3.25)
+project(${projectName} LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FetchContent)
+set(FETCHCONTENT_QUIET OFF)
+
+FetchContent_Declare(
+    imx
+    GIT_REPOSITORY https://github.com/bgocumlu/imx.git
+    GIT_TAG v0.6.1
+    GIT_SHALLOW TRUE
+    GIT_PROGRESS TRUE
+)
+message(STATUS "Fetching IMX (includes ImGui + GLFW)...")
+FetchContent_MakeAvailable(imx)
+
+include(ImxCompile)
+
+imx_compile_tsx(GENERATED
+    SOURCES src/App.tsx
+    OUTPUT_DIR \${CMAKE_BINARY_DIR}/generated
+)
+
+# UI shared library (hot-reloadable)
+add_library(imx_ui SHARED
+    src/ui_entry.cpp
+    \${GENERATED}
+)
+target_link_libraries(imx_ui PRIVATE imx::renderer)
+target_include_directories(imx_ui PRIVATE \${CMAKE_BINARY_DIR}/generated \${CMAKE_CURRENT_SOURCE_DIR}/src)
+
+# Host executable (loads UI module dynamically)
+add_executable(${projectName}
+    src/main.cpp
+)
+set_target_properties(${projectName} PROPERTIES WIN32_EXECUTABLE $<CONFIG:Release>)
+target_link_libraries(${projectName} PRIVATE imx::renderer \${CMAKE_DL_LIBS})
+target_include_directories(${projectName} PRIVATE \${CMAKE_CURRENT_SOURCE_DIR}/src)
+
+# Copy DLL/SO next to host exe after build
+add_custom_command(TARGET imx_ui POST_BUILD
+    COMMAND \${CMAKE_COMMAND} -E copy $<TARGET_FILE:imx_ui> $<TARGET_FILE_DIR:${projectName}>
+    COMMENT "Copying UI module to host directory"
+)
+add_dependencies(${projectName} imx_ui)
+
+# Copy public/ assets to output directory
+add_custom_command(TARGET ${projectName} POST_BUILD
+    COMMAND \${CMAKE_COMMAND} -E copy_directory
+        \${CMAKE_CURRENT_SOURCE_DIR}/public
+        $<TARGET_FILE_DIR:${projectName}>
+    COMMENT "Copying public/ assets"
+)
+`;
+}
+function generate(projectDir, projectName) {
+    const srcDir = path.join(projectDir, 'src');
+    if (fs.existsSync(path.join(srcDir, 'App.tsx'))) {
+        console.error(`Error: ${srcDir}/App.tsx already exists. Aborting.`);
+        process.exit(1);
+    }
+    fs.mkdirSync(srcDir, { recursive: true });
+    const publicDir = path.join(projectDir, 'public');
+    fs.mkdirSync(publicDir, { recursive: true });
+    // Write files
+    fs.writeFileSync(path.join(srcDir, 'main.cpp'), MAIN_CPP.replaceAll('APP_NAME', projectName));
+    fs.writeFileSync(path.join(srcDir, 'AppState.h'), APPSTATE_H);
+    fs.writeFileSync(path.join(srcDir, 'hotreload.h'), HOTRELOAD_H);
+    fs.writeFileSync(path.join(srcDir, 'ui_entry.cpp'), UI_ENTRY_CPP);
+    fs.writeFileSync(path.join(srcDir, 'App.tsx'), APP_TSX);
+    fs.writeFileSync(path.join(srcDir, 'imx.d.ts'), buildImxDts(APPSTATE_INTERFACE));
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), TSCONFIG);
+    fs.writeFileSync(path.join(projectDir, 'CMakeLists.txt'), cmakeHotreload(projectName));
+    fs.writeFileSync(path.join(projectDir, '.gitignore'), GITIGNORE);
+    console.log(`imxc: initialized project "${projectName}" with template "hotreload"`);
+    console.log('');
+    console.log('  Created:');
+    console.log(`    src/main.cpp          — host exe with DLL hot reload loop`);
+    console.log(`    src/AppState.h        — C++ state struct (lives in host, survives reloads)`);
+    console.log(`    src/hotreload.h       — cross-platform DLL/SO loader`);
+    console.log(`    src/ui_entry.cpp      — DLL export wrapper for imx_render()`);
+    console.log(`    src/App.tsx           — your root component (compiled into DLL)`);
+    console.log(`    src/imx.d.ts          — type definitions for IDE support`);
+    console.log(`    tsconfig.json         — TypeScript config`);
+    console.log(`    CMakeLists.txt        — build config with host exe + UI shared lib`);
+    console.log(`    .gitignore            — ignores build/, node_modules/, *.ini`);
+    console.log(`    public/               — static assets (copied to exe directory)`);
+    console.log('');
+    console.log('  Next steps:');
+    console.log(`    cd ${projectName}`);
+    console.log(`    cmake -B build`);
+    console.log(`    cmake --build build`);
+}
+registerTemplate({ name: 'hotreload', description: 'DLL hot reload for live UI iteration', generate });