Feature/fix glsl tests

.cursorrules

@@ -4,10 +4,31 @@
 
 # Commits: Commit frequently with small incremental changes
 
-# Commits: Keep commit messages short (one line when possible)
+# Commits: Use Conventional Commits format: `<type>(<scope>): <description>`
+#   - Types: feat, fix, chore, docs, etc.
+#   - Scope: sbs, osmt, wrappers, etc. (or component name)
+#   - Description: short description of the commit
+#   - Body: optional, include only if changes are not obvious from description
+#   - Body format: bulleted list of changes made, each item a single line
 
 # Commits: Keep code compiling and tests passing between commits (when possible)
 
+# Formatting: Run `cargo +nightly fmt` on all changes before committing
+
+# Code Organization: Place helper utility functions at the bottom of files
+# Code Organization: Place more abstract things, entry points, and tests first
+# Code Organization: Keep related functionality grouped together
+
+# Tests: Tests should be in `mod tests` at the top of the module
+# Tests: Tests should be short and concise, use utility functions to avoid duplication
+# Tests: Utility functions should be at the bottom of the test module
+# Tests: Use builder pattern to create test data
+
+# Language: Keep language professional and restrained
+# Language: Avoid overly optimistic language like "comprehensive", "fully production ready", "complete solution"
+# Language: Avoid emoticons
+# Language: Use measured, factual descriptions of what was implemented
+
 # Style: Follow existing cranelift code style
 
 # Style: Use `#![no_std]` where appropriate

.github/workflows/pre-merge.yml

@@ -0,0 +1,49 @@
+name: CI
+
+on:
+  pull_request:
+    branches: ["feature/*"]
+  push:
+    branches: ["feature/*"]
+
+env:
+  RUST_BACKTRACE: 1
+  RISC_V_TARGET: riscv32imac-unknown-none-elf
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-24.04-arm
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - name: Install RISC-V target
+        run: rustup target add ${{ env.RISC_V_TARGET }}
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: Install just
+        uses: extractions/setup-just@v3
+
+      - name: Validate
+        # Note: we don't run tests on ci right now because jit tests fail on arm
+        #       due to memory protection, and don't run on x64 due to some cranelift
+        #       x64 build issue.
+        run: just check build

.gitignore

@@ -23,6 +23,7 @@ vendor
 *.smt2
 *.cwasm
 /artifacts
+.ci-artifacts
 testcase*.wat
 testcase*.wasm
 testcase*.dna

Cargo.toml

@@ -15,14 +15,36 @@ members = [
     "lp-glsl/crates/lp-jit-util",
     "lp-glsl/crates/lp-riscv-shared",
     "lp-glsl/crates/lp-riscv-tools",
-    "lp-glsl/apps/esp32-glsl-jit",
     "lp-glsl/apps/lp-builtin-gen",
     "lp-glsl/apps/lp-builtins-app",
     "lp-glsl/apps/lp-test",
-    "lp-glsl/apps/test-structreturn",
+    "lp-glsl/apps/esp32-glsl-jit",
 ]
 resolver = "2"
 
+# Exclude lp-builtins-app and esp32-glsl-jit from default workspace builds (they're no_std, only build for RISC-V)
+# They're still in workspace members so they can use workspace dependencies
+# Build them explicitly with: just build-builtins or just esp32-build
+default-members = [
+    # lp-app workspace members
+    "lp-app/crates/lp-engine",
+    "lp-app/crates/lp-engine-client",
+    "lp-app/crates/lp-shared",
+    "lp-app/crates/lp-server",
+    "lp-app/apps/lp-cli",
+    "lp-app/crates/lp-model",
+    # lp-glsl workspace members (excluding lp-builtins-app)
+    "lp-glsl/crates/lp-builtins",
+    "lp-glsl/crates/lp-filetests-gen",
+    "lp-glsl/crates/lp-glsl-compiler",
+    "lp-glsl/crates/lp-glsl-filetests",
+    "lp-glsl/crates/lp-jit-util",
+    "lp-glsl/crates/lp-riscv-shared",
+    "lp-glsl/crates/lp-riscv-tools",
+    "lp-glsl/apps/lp-builtin-gen",
+    "lp-glsl/apps/lp-test",
+]
+
 [workspace.package]
 version = "40.0.0"
 authors = ["The Wasmtime Project Developers"]
@@ -71,6 +93,7 @@ cranelift-interpreter = { git = "https://github.com/Yona-Appletree/lp-cranelift.
 target-lexicon = "0.13.0"
 hashbrown = { version = "0.15", default-features = false, features = ["alloc", "default-hasher"] }
 anyhow = { version = "1.0.100", default-features = false }
+log = { version = "0.4", default-features = false }
 regex = "1.9.1"
 glob = "0.3.3"
 object = { version = "0.37.3", default-features = false, features = ['read_core', 'elf'] }
@@ -83,11 +106,12 @@ serde_json = { version = "1.0.80", default-features = false, features = ["alloc"
 # This applies to all packages in the workspace
 lto = true
 
+# ESP32 app release profile optimizations (embedded target)
 [profile.release.package.esp32-glsl-jit]
-# Size optimizations for embedded target (ESP32-C3)
 # Strip debuginfo but keep symbols (needed for defmt/probe-rs) - saves ~1-1.5 MB
 strip = "debuginfo"
 # Optimize for size instead of speed - saves ~200-500 KB
 opt-level = "z"
 # Single codegen unit for better dead code elimination - saves ~50-100 KB
 codegen-units = 1
+# Note: lto is inherited from workspace [profile.release]

README.md

@@ -1,23 +1,34 @@
 # LightPlayer Application
 
-LightPlayer is a framework for building and deploying interactive visualization applications
-using GLSL primarily for addressable LED control on embedded systems.
+LightPlayer is a framework for building and deploying interactive visual effects on microcontrollers and other embedded systems.
 
-It employs a client-server architecture, where the server runs the visualization on
-a headless machine (e.g. an esp32-c6 or raspberry pi), and the client communicates with
-the server via a network or serial connection.
+Effects are written as GLSL shaders a custom native compiler is used to allow running them on hardware without OpenGL, including microcontrollers.
 
-The server portion is portable, and is designed to be runnable from any OS for
-development, a headless host for larger deployments, or as bare-metal firmware
-on an embedded system.
+## Development Setup
 
-On machines without OpenGL support, such as embedded systems, the shaders are compiled to native
-code using the bespoke LightPlayer GLSL compiler which is built on a fork of Cranelift.
+To get started with development:
 
-# Workspace
+1. **Initialize the development environment:**
 
-This workspace contains the main LightPlayer application, including the device specific firmware,
-engine, server, and clients.
+   ```bash
+   scripts/dev-init.sh
+   ```
 
-It exists within cranelift temporarily during active development of the compiler, because managing
-multiple repositories is too cumbersome.
+   This will:
+   - Check for required tools (Rust, Cargo, rustup, just)
+   - Verify Rust version meets minimum requirements (1.90.0+)
+   - Install the RISC-V target (`riscv32imac-unknown-none-elf`) if needed
+   - Set up git hooks (pre-commit hook runs `just check`)
+
+2. **Required tools:**
+   - Rust toolchain (1.90.0 or later) - [Install Rust](https://rustup.rs/)
+   - `just` - Task runner: `cargo install just` or via package manager
+
+3. **Common development commands:**
+   - `just build` - Build all packages (host and RISC-V targets)
+   - `just check` - Run formatting and linting checks
+   - `just test` - Run all tests
+   - `just fmt` - Format code
+   - `just fix` - Format code and auto-fix clippy issues
+
+See `just --list` for all available commands.