gelang 0.1.0

package/python/pyeffic/templates/desktop_gui/app/core/multiply.ge.py

@@ -0,0 +1,13 @@
+"""Core function: multiply. Compiled to C++ for performance.
+
+One function per file (C++ Core Guidelines SF.1-SF.5): each function is a
+separate compilation unit with a clear dependency list.
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+
+
+@cpp
+def multiply(a: int, b: int) -> int:
+    """Multiply two integers."""
+    return a * b

package/python/pyeffic/templates/desktop_gui/app/core/power.ge.py

@@ -0,0 +1,25 @@
+"""Core function: power. Compiled to C++ for performance.
+
+One function per file (C++ Core Guidelines SF.1-SF.5): each function is a
+separate compilation unit with a clear dependency list.
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+
+
+@cpp
+def power(base: int, exp: int) -> int:
+    """Fast exponentiation: base raised to exp."""
+    if exp == 0:
+        return 1
+    if exp < 0:
+        return 0
+    result: int = 1
+    b: int = base
+    e: int = exp
+    while e > 0:
+        if e % 2 == 1:
+            result = result * b
+        b = b * b
+        e = e // 2
+    return result

package/python/pyeffic/templates/desktop_gui/app/main.ge.py

@@ -0,0 +1,49 @@
+"""{app_name} — application aggregator.
+
+Single import surface for platform entry points. Import order matters:
+theme before layout/widgets/render, so the C++ preamble declares the
+Win32 SDK before anything that uses it.
+
+Layers:
+  app/memory/  Rust  — bounded state, buffers, limits
+  app/core/    C++   — computation (one function per file)
+  app/ui/      C++   — theme, layout, widgets, render
+"""
+from __future__ import annotations
+
+# --- Memory layer (Rust) ---
+from app.memory.limits import (
+    mem_input_min, mem_input_max, mem_clamp_input, mem_step_up, mem_step_down,
+)
+from app.memory.buffer import (
+    mem_buffer_capacity, mem_digits_capacity, mem_state_slots,
+)
+from app.memory.state import (
+    mem_initial_input, mem_initial_result, mem_initial_op,
+    mem_op_count, mem_next_op, mem_normalize_input,
+)
+
+# --- Core functions (C++) ---
+from app.core.add import add
+from app.core.multiply import multiply
+from app.core.factorial import factorial
+from app.core.fibonacci import fibonacci
+from app.core.is_prime import is_prime
+from app.core.gcd import gcd
+from app.core.power import power
+
+# --- UI layer (C++), theme first ---
+from app.ui.theme import (
+    ui_color_bg, ui_color_panel, ui_color_card, ui_color_accent,
+    ui_color_text, ui_color_text_dim, ui_color_success, ui_color_warning,
+    ui_color_grid, ui_font_title, ui_font_heading, ui_font_body, ui_font_small,
+    ui_space_xs, ui_space_sm, ui_space_md, ui_space_lg, ui_radius,
+)
+from app.ui.layout import (
+    ui_sidebar_width, ui_content_x, ui_card_x, ui_card_y,
+    ui_card_width, ui_card_height, ui_controls_y, ui_row_y, ui_center_x,
+)
+from app.ui.widgets import (
+    ui_draw_panel, ui_draw_card, ui_draw_text, ui_draw_number, ui_draw_grid,
+)
+from app.ui.render import ui_draw_frame

package/python/pyeffic/templates/desktop_gui/app/memory/buffer.ge.py

@@ -0,0 +1,26 @@
+"""Memory buffers — fixed-size capacities. Compiled to Rust.
+
+The app formats numbers into fixed-size stack buffers instead of
+heap-allocating Strings. These functions expose the capacities so the
+Rust shell and the C++ UI layer agree on the same bounds.
+"""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+def mem_buffer_capacity() -> int:
+    """Capacity of a general text buffer (bytes)."""
+    return 64
+
+
+@rust
+def mem_digits_capacity() -> int:
+    """Capacity of the scratch buffer used for integer digits."""
+    return 20
+
+
+@rust
+def mem_state_slots() -> int:
+    """Number of fixed app-state slots (input, result, op)."""
+    return 3

package/python/pyeffic/templates/desktop_gui/app/memory/limits.ge.py

@@ -0,0 +1,47 @@
+"""Memory limits — bounded ranges for app state. Compiled to Rust.
+
+This is the memory-safety boundary of the app. Every value that can grow
+is bounded here so no computation can overflow or allocate without limit.
+
+Rust design principle: "bound everything that can grow".
+"""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+def mem_input_min() -> int:
+    """Minimum allowed input value."""
+    return 0
+
+
+@rust
+def mem_input_max() -> int:
+    """Maximum allowed input value.
+
+    Kept at 20 so factorial(n) fits in a signed 64-bit integer
+    (21! overflows i64). Bounding here prevents overflow at the source.
+    """
+    return 20
+
+
+@rust
+def mem_clamp_input(value: int) -> int:
+    """Clamp a value into the allowed input range."""
+    if value < mem_input_min():
+        return mem_input_min()
+    if value > mem_input_max():
+        return mem_input_max()
+    return value
+
+
+@rust
+def mem_step_up(value: int) -> int:
+    """Increment a value, clamped to the max."""
+    return mem_clamp_input(value + 1)
+
+
+@rust
+def mem_step_down(value: int) -> int:
+    """Decrement a value, clamped to the min."""
+    return mem_clamp_input(value - 1)

package/python/pyeffic/templates/desktop_gui/app/memory/state.ge.py

@@ -0,0 +1,44 @@
+"""Memory state — bounded application state. Compiled to Rust.
+
+The GUI keeps a fixed number of scalar slots. No collections grow at
+runtime, so memory use is constant regardless of how long the app runs.
+"""
+from __future__ import annotations
+from pyeffic.backends import rust
+from app.memory.limits import mem_clamp_input
+
+
+@rust
+def mem_initial_input() -> int:
+    """Initial input value at startup."""
+    return 10
+
+
+@rust
+def mem_initial_result() -> int:
+    """Initial result value at startup."""
+    return 0
+
+
+@rust
+def mem_initial_op() -> int:
+    """Initial operation code (0 = factorial)."""
+    return 0
+
+
+@rust
+def mem_op_count() -> int:
+    """Number of supported operations."""
+    return 4
+
+
+@rust
+def mem_next_op(op: int) -> int:
+    """Cycle to the next operation code."""
+    return (op + 1) % mem_op_count()
+
+
+@rust
+def mem_normalize_input(value: int) -> int:
+    """Normalize an input value into the bounded range."""
+    return mem_clamp_input(value)

package/python/pyeffic/templates/desktop_gui/app/ui/layout.ge.py

@@ -0,0 +1,64 @@
+"""UI layout — geometry math. Compiled to C++.
+
+Pure coordinate math: no drawing, no state. Kept separate from
+widgets.ge.py so layout can be reasoned about (and tested) on its own.
+
+Depends on: theme.ge.py
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+from app.ui.theme import ui_space_md, ui_space_lg
+
+
+@cpp
+def ui_sidebar_width() -> int:
+    """Sidebar width in pixels."""
+    return 300
+
+
+@cpp
+def ui_content_x() -> int:
+    """Left edge of the content area."""
+    return ui_sidebar_width() + ui_space_md()
+
+
+@cpp
+def ui_card_x() -> int:
+    """Main card left edge."""
+    return ui_content_x()
+
+
+@cpp
+def ui_card_y() -> int:
+    """Main card top edge."""
+    return ui_space_lg() + 60
+
+
+@cpp
+def ui_card_width(window_width: int) -> int:
+    """Main card width."""
+    return window_width - ui_card_x() - ui_space_md()
+
+
+@cpp
+def ui_card_height(window_height: int) -> int:
+    """Main card height."""
+    return window_height - ui_card_y() - 60
+
+
+@cpp
+def ui_controls_y(window_height: int) -> int:
+    """Y position of the controls hint block."""
+    return window_height - 140
+
+
+@cpp
+def ui_row_y(row: int) -> int:
+    """Y position of sidebar row `row`."""
+    return 80 + row * 34
+
+
+@cpp
+def ui_center_x(container_x: int, container_w: int, item_w: int) -> int:
+    """X position that centers an item inside a container."""
+    return container_x + (container_w - item_w) / 2

package/python/pyeffic/templates/desktop_gui/app/ui/render.ge.py

@@ -0,0 +1,87 @@
+"""UI render — frame orchestrator. Compiled to C++.
+
+Draws one complete frame. Called from the Rust shell on WM_PAINT with the
+raw HDC handle. Composition order:
+
+  background -> grid -> sidebar -> sidebar text -> card -> card content -> footer
+
+Depends on: theme.ge.py, layout.ge.py, widgets.ge.py
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+from app.ui.theme import (
+    ui_color_bg, ui_color_panel, ui_color_accent, ui_color_text,
+    ui_color_text_dim, ui_color_success, ui_color_grid,
+    ui_font_title, ui_font_body, ui_font_small,
+)
+from app.ui.layout import (
+    ui_sidebar_width, ui_content_x, ui_card_x, ui_card_y,
+    ui_card_width, ui_card_height, ui_controls_y, ui_row_y,
+)
+from app.ui.widgets import (
+    ui_draw_panel, ui_draw_card, ui_draw_text, ui_draw_number, ui_draw_grid,
+)
+
+
+@cpp
+def ui_draw_frame(hdc_val: int, width: int, height: int,
+                  input_val: int, result_val: int, op: int) -> int:
+    """Draw the whole application frame."""
+    ge_inline("cpp", """
+    HDC hdc = (HDC)(intptr_t)hdc_val;
+
+    ui_draw_panel(hdc_val, 0, 0, width, height, ui_color_bg());
+    ui_draw_grid(hdc_val, width, height, 40, ui_color_grid());
+    ui_draw_panel(hdc_val, 0, 0, ui_sidebar_width(), height, ui_color_panel());
+
+    ui_draw_text(hdc_val, "{app_name}", 16, 16, ui_sidebar_width() - 32,
+                 ui_font_title(), ui_color_accent(), 1);
+    ui_draw_text(hdc_val, "Rust memory + C++ functions", 16, 50,
+                 ui_sidebar_width() - 32, ui_font_small(), ui_color_text_dim(), 0);
+
+    ui_draw_text(hdc_val, "Input", 16, ui_row_y(0), 90,
+                 ui_font_small(), ui_color_text_dim(), 0);
+    ui_draw_number(hdc_val, input_val, 110, ui_row_y(0), 170,
+                   ui_font_body(), ui_color_text(), 1);
+
+    const char* op_names[4] = { "factorial", "fibonacci", "is_prime", "gcd" };
+    const char* op_label = (op >= 0 && op < 4) ? op_names[op] : "?";
+    ui_draw_text(hdc_val, "Operation", 16, ui_row_y(1), 90,
+                 ui_font_small(), ui_color_text_dim(), 0);
+    ui_draw_text(hdc_val, op_label, 110, ui_row_y(1), 170,
+                 ui_font_small(), ui_color_warning(), 0);
+
+    ui_draw_text(hdc_val, "Result", 16, ui_row_y(2), 90,
+                 ui_font_small(), ui_color_text_dim(), 0);
+    ui_draw_number(hdc_val, result_val, 110, ui_row_y(2), 170,
+                   ui_font_body(), ui_color_success(), 1);
+
+    int cy = ui_controls_y(height);
+    ui_draw_text(hdc_val, "Controls", 16, cy, ui_sidebar_width() - 32,
+                 ui_font_body(), ui_color_text(), 1);
+    ui_draw_text(hdc_val, "Up / Down   change input", 16, cy + 26,
+                 ui_sidebar_width() - 32, ui_font_small(), ui_color_text_dim(), 0);
+    ui_draw_text(hdc_val, "Enter       run operation", 16, cy + 44,
+                 ui_sidebar_width() - 32, ui_font_small(), ui_color_text_dim(), 0);
+    ui_draw_text(hdc_val, "F / P / G   fib / prime / gcd", 16, cy + 62,
+                 ui_sidebar_width() - 32, ui_font_small(), ui_color_text_dim(), 0);
+    ui_draw_text(hdc_val, "Esc         quit", 16, cy + 80,
+                 ui_sidebar_width() - 32, ui_font_small(), ui_color_text_dim(), 0);
+
+    ui_draw_card(hdc_val, ui_card_x(), ui_card_y(),
+                 ui_card_width(width), ui_card_height(height));
+    ui_draw_text(hdc_val, "C++ Core Function", ui_card_x(), ui_card_y() + 20,
+                 ui_card_width(width), ui_font_body(), ui_color_text(), 1);
+    ui_draw_text(hdc_val, "Computed in C++ - drawn in C++ - driven by Rust",
+                 ui_card_x(), ui_card_y() + 50, ui_card_width(width),
+                 ui_font_small(), ui_color_text_dim(), 0);
+    ui_draw_number(hdc_val, result_val, ui_card_x(), ui_card_y() + 100,
+                   ui_card_width(width), ui_font_title(), ui_color_success(), 1);
+
+    ui_draw_text(hdc_val, "{app_name} v0.1.0 - Rust + C++ Desktop",
+                 ui_content_x(), height - 30, ui_card_width(width),
+                 ui_font_small(), ui_color_text_dim(), 0);
+
+    return 0;
+    """)
+    return 0

package/python/pyeffic/templates/desktop_gui/app/ui/theme.ge.py

@@ -0,0 +1,147 @@
+"""UI theme — design tokens. Compiled to C++.
+
+Modern dark theme (Fluent-2 / Tailwind-inspired palette).
+This file owns the Win32 includes for the whole C++ layer.
+
+UI layer structure (one concern per file):
+  theme.ge.py   — colors, font sizes, spacing (this file)
+  layout.ge.py  — geometry math
+  widgets.ge.py — drawing primitives
+  render.ge.py  — frame orchestrator
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+
+# Win32 SDK includes — injected at file scope, before all functions.
+ge_preamble("cpp", """
+#include <windows.h>
+#include <windowsx.h>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#pragma comment(lib, "user32.lib")
+#pragma comment(lib, "gdi32.lib")
+""")
+
+
+# --- Colors ---
+
+@cpp
+def ui_color_bg() -> int:
+    """Window background (deep slate)."""
+    ge_inline("cpp", "return (int)RGB(15, 23, 42);")
+    return 0
+
+
+@cpp
+def ui_color_panel() -> int:
+    """Sidebar panel background."""
+    ge_inline("cpp", "return (int)RGB(30, 41, 59);")
+    return 0
+
+
+@cpp
+def ui_color_card() -> int:
+    """Card background."""
+    ge_inline("cpp", "return (int)RGB(30, 41, 59);")
+    return 0
+
+
+@cpp
+def ui_color_accent() -> int:
+    """Primary accent (blue)."""
+    ge_inline("cpp", "return (int)RGB(96, 165, 250);")
+    return 0
+
+
+@cpp
+def ui_color_text() -> int:
+    """Primary text."""
+    ge_inline("cpp", "return (int)RGB(241, 245, 249);")
+    return 0
+
+
+@cpp
+def ui_color_text_dim() -> int:
+    """Muted text."""
+    ge_inline("cpp", "return (int)RGB(148, 163, 184);")
+    return 0
+
+
+@cpp
+def ui_color_success() -> int:
+    """Success / result (green)."""
+    ge_inline("cpp", "return (int)RGB(74, 222, 128);")
+    return 0
+
+
+@cpp
+def ui_color_warning() -> int:
+    """Warning (amber)."""
+    ge_inline("cpp", "return (int)RGB(251, 191, 36);")
+    return 0
+
+
+@cpp
+def ui_color_grid() -> int:
+    """Background grid dots."""
+    ge_inline("cpp", "return (int)RGB(51, 65, 85);")
+    return 0
+
+
+# --- Font sizes ---
+
+@cpp
+def ui_font_title() -> int:
+    """Title font size."""
+    return 24
+
+
+@cpp
+def ui_font_heading() -> int:
+    """Heading font size."""
+    return 18
+
+
+@cpp
+def ui_font_body() -> int:
+    """Body font size."""
+    return 15
+
+
+@cpp
+def ui_font_small() -> int:
+    """Caption font size."""
+    return 13
+
+
+# --- Spacing / radius ---
+
+@cpp
+def ui_space_xs() -> int:
+    """Extra-small spacing."""
+    return 4
+
+
+@cpp
+def ui_space_sm() -> int:
+    """Small spacing."""
+    return 8
+
+
+@cpp
+def ui_space_md() -> int:
+    """Medium spacing."""
+    return 16
+
+
+@cpp
+def ui_space_lg() -> int:
+    """Large spacing."""
+    return 24
+
+
+@cpp
+def ui_radius() -> int:
+    """Corner radius."""
+    return 12

package/python/pyeffic/templates/desktop_gui/app/ui/widgets.ge.py

@@ -0,0 +1,105 @@
+"""UI widgets — drawing primitives. Compiled to C++.
+
+Each function draws exactly one primitive onto a raw HDC passed from the
+Rust shell. No application state lives here.
+
+Depends on: theme.ge.py
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+from app.ui.theme import (
+    ui_color_card, ui_color_accent, ui_radius,
+)
+
+
+@cpp
+def ui_draw_panel(hdc_val: int, x: int, y: int, w: int, h: int, color: int) -> int:
+    """Fill a rectangle."""
+    ge_inline("cpp", """
+    HDC hdc = (HDC)(intptr_t)hdc_val;
+    RECT rc = { (LONG)x, (LONG)y, (LONG)(x + w), (LONG)(y + h) };
+    HBRUSH brush = CreateSolidBrush((COLORREF)color);
+    FillRect(hdc, &rc, brush);
+    DeleteObject(brush);
+    return 0;
+    """)
+    return 0
+
+
+@cpp
+def ui_draw_card(hdc_val: int, x: int, y: int, w: int, h: int) -> int:
+    """Draw a rounded card with an accent border."""
+    ge_inline("cpp", """
+    HDC hdc = (HDC)(intptr_t)hdc_val;
+    HBRUSH brush = CreateSolidBrush((COLORREF)ui_color_card());
+    HPEN pen = CreatePen(PS_SOLID, 2, (COLORREF)ui_color_accent());
+    HBRUSH old_brush = (HBRUSH)SelectObject(hdc, brush);
+    HPEN old_pen = (HPEN)SelectObject(hdc, pen);
+    RoundRect(hdc, (int)x, (int)y, (int)(x + w), (int)(y + h),
+              ui_radius() * 2, ui_radius() * 2);
+    SelectObject(hdc, old_brush);
+    SelectObject(hdc, old_pen);
+    DeleteObject(brush);
+    DeleteObject(pen);
+    return 0;
+    """)
+    return 0
+
+
+@cpp
+def ui_draw_text(hdc_val: int, text: str, x: int, y: int, w: int,
+                 size: int, color: int, bold: int) -> int:
+    """Draw centered single-line text."""
+    ge_inline("cpp", """
+    HDC hdc = (HDC)(intptr_t)hdc_val;
+    HFONT font = CreateFontA((int)size, 0, 0, 0, bold ? FW_BOLD : FW_NORMAL,
+        FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
+        CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY,
+        DEFAULT_PITCH | FF_SWISS, "Segoe UI");
+    HFONT old = (HFONT)SelectObject(hdc, font);
+    SetBkMode(hdc, TRANSPARENT);
+    SetTextColor(hdc, (COLORREF)color);
+    RECT rc = { (LONG)x, (LONG)y, (LONG)(x + w), (LONG)(y + size + 10) };
+    DrawTextA(hdc, text.c_str(), -1, &rc, DT_CENTER | DT_SINGLELINE | DT_VCENTER);
+    SelectObject(hdc, old);
+    DeleteObject(font);
+    return 0;
+    """)
+    return 0
+
+
+@cpp
+def ui_draw_number(hdc_val: int, value: int, x: int, y: int, w: int,
+                   size: int, color: int, bold: int) -> int:
+    """Draw an integer using a fixed-size stack buffer (no heap allocation)."""
+    ge_inline("cpp", """
+    HDC hdc = (HDC)(intptr_t)hdc_val;
+    char buf[64];
+    snprintf(buf, sizeof(buf), "%lld", (long long)value);
+    HFONT font = CreateFontA((int)size, 0, 0, 0, bold ? FW_BOLD : FW_NORMAL,
+        FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
+        CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY,
+        DEFAULT_PITCH | FF_SWISS, "Segoe UI");
+    HFONT old = (HFONT)SelectObject(hdc, font);
+    SetBkMode(hdc, TRANSPARENT);
+    SetTextColor(hdc, (COLORREF)color);
+    RECT rc = { (LONG)x, (LONG)y, (LONG)(x + w), (LONG)(y + size + 10) };
+    DrawTextA(hdc, buf, -1, &rc, DT_CENTER | DT_SINGLELINE | DT_VCENTER);
+    SelectObject(hdc, old);
+    DeleteObject(font);
+    return 0;
+    """)
+    return 0
+
+
+@cpp
+def ui_draw_grid(hdc_val: int, width: int, height: int, spacing: int, color: int) -> int:
+    """Draw a dotted background grid."""
+    ge_inline("cpp", """
+    HDC hdc = (HDC)(intptr_t)hdc_val;
+    for (int gx = 0; gx < (int)width; gx += (int)spacing)
+        for (int gy = 0; gy < (int)height; gy += (int)spacing)
+            SetPixel(hdc, gx, gy, (COLORREF)color);
+    return 0;
+    """)
+    return 0

package/python/pyeffic/templates/desktop_gui/desktop/__init__.py

@@ -0,0 +1 @@
+