feat(reox): UI framework enhancements

- Add stdlib modules: core.rs, io.rs, ui.rs
- Add ViewModifier, ContainerBuilder for SwiftUI-like patterns
- Add widget builders: ButtonBuilder, TextBuilder, InputBuilder, etc.
- Enhance codegen to emit reox FFI calls for UI widgets
- Add animation easing functions to interpreter
- Add theme colors (color_primary, color_success, etc.)
- Add AI helper functions (ai_complete, ai_explain, ai_fix)
- Fix float arithmetic and comparisons in interpreter

Author: swanaya

docs/reox_health_report.md

@@ -1,12 +1,12 @@
 # REOX Language Health Report
 
-**Date:** January 18, 2026  
+**Date:** January 28, 2026  
 **Version:** Pre-v1  
-**Last Updated:** After async/await implementation
+**Last Updated:** After float arithmetic and clippy fixes
 
 ## 📊 Executive Summary
 
-The REOX compiler (`reoxc`) has made significant progress toward v1 readiness. Recent updates have addressed critical issues including async/await support, match expressions, and bitwise operators. The compiler now successfully compiles control flow, function calls, match expressions, and async/await to C code.
+The REOX compiler (`reoxc`) has made significant progress toward v1 readiness. Recent updates have addressed critical issues including async/await support, match expressions, bitwise operators, and float arithmetic. The interpreter now fully supports float operations and mixed int/float arithmetic.
 
 ## ✅ Recently Fixed
 
@@ -42,6 +42,21 @@ The REOX compiler (`reoxc`) has made significant progress toward v1 readiness. R
   - Typechecker enforces int operands
   - Codegen passes through to C operators
 
+### 4. Float Arithmetic - **IMPLEMENTED**
+
+- **Status:** Working (Jan 28, 2026)
+- **Implementation:**
+  - All arithmetic operators (+, -, \*, /, %) now support float types
+  - Mixed int/float operations auto-promote to float
+  - Comparison operators (<, >, <=, >=) work with floats
+  - Float equality uses epsilon comparison
+- **Usage:**
+  ```reox
+  let x: float = 3.14;
+  let y: float = x * 2.0;  // 6.28
+  let z: float = 1 + 0.5;  // Mixed: 1.5
+  ```
+
 ## 🟡 Improvement Areas
 
 ### 1. Match Type Inference (Low Priority)

reox-lang/src/codegen/mod.rs

@@ -350,15 +350,42 @@ impl CodeGen {
     }
 
     fn gen_for(&mut self, f: &ForStmt) {
-        // Convert to C-style for loop (simplified - assumes iterable is range)
-        self.emit_indent();
-        self.emit(&format!("for (int {} = 0; {} < ", f.var, f.var));
-        self.gen_expr(&f.iterable);
-        self.emit(&format!("; {}++) {{\n", f.var));
-        self.indent();
-        self.gen_block(&f.body);
-        self.dedent();
-        self.emit_line("}");
+        match &f.iterable {
+            Expr::Range(start, end, _) => {
+                // Optimized C loop: for (int64_t i = start; i <= end; ++i)
+                self.emit_indent();
+                self.emit(&format!("for (int64_t {} = ", f.var));
+                self.gen_expr(start);
+                self.emit(&format!("; {} <= ", f.var));
+                self.gen_expr(end);
+                self.emit(&format!("; ++{}) {{\n", f.var));
+                self.indent();
+                self.gen_block(&f.body);
+                self.dedent();
+                self.emit_line("}");
+            }
+            _ => {
+                // Default array iteration (simplified for C)
+                // Assuming iterable is an array pointer or similar convention
+                // This would typically rely on a runtime iterator or Array struct in C
+                self.emit_indent();
+                // Create unique iterator name
+                let iter_name = format!("_iter_{}", f.var);
+                self.emit(&format!("array_t* {} = ", iter_name));
+                self.gen_expr(&f.iterable);
+                self.emit(";\n");
+                
+                self.emit_indent();
+                self.emit(&format!("for (int64_t _i = 0; _i < {}->length; ++_i) {{\n", iter_name));
+                self.indent();
+                self.emit_indent();
+                // Extract item
+                self.emit(&format!("int64_t {} = {}->data[_i];\n", f.var, iter_name));
+                self.gen_block(&f.body);
+                self.dedent();
+                self.emit_line("}");
+            }
+        }
     }
 
     fn gen_expr(&mut self, expr: &Expr) {
@@ -377,6 +404,98 @@ impl CodeGen {
                 self.gen_expr(operand);
             }
             Expr::Call(callee, args, _) => {
+                // Check for UI widget function calls
+                if let Expr::Identifier(name, _) = callee.as_ref() {
+                    match name.as_str() {
+                        // UI Widget constructors -> emit reox FFI calls
+                        "button" => {
+                            self.emit("reox_button_create(");
+                            for (i, arg) in args.iter().enumerate() {
+                                if i > 0 { self.emit(", "); }
+                                self.gen_expr(arg);
+                            }
+                            self.emit(")");
+                            return;
+                        }
+                        "text" | "label" => {
+                            self.emit("reox_label_create(");
+                            for (i, arg) in args.iter().enumerate() {
+                                if i > 0 { self.emit(", "); }
+                                self.gen_expr(arg);
+                            }
+                            self.emit(")");
+                            return;
+                        }
+                        "input" | "textfield" => {
+                            self.emit("reox_textfield_create(");
+                            for (i, arg) in args.iter().enumerate() {
+                                if i > 0 { self.emit(", "); }
+                                self.gen_expr(arg);
+                            }
+                            self.emit(")");
+                            return;
+                        }
+                        "slider" => {
+                            self.emit("reox_slider_create(");
+                            for (i, arg) in args.iter().enumerate() {
+                                if i > 0 { self.emit(", "); }
+                                self.gen_expr(arg);
+                            }
+                            self.emit(")");
+                            return;
+                        }
+                        "checkbox" => {
+                            self.emit("reox_checkbox_create(");
+                            for (i, arg) in args.iter().enumerate() {
+                                if i > 0 { self.emit(", "); }
+                                self.gen_expr(arg);
+                            }
+                            self.emit(")");
+                            return;
+                        }
+                        "vstack" => {
+                            self.emit("reox_vstack(");
+                            if !args.is_empty() {
+                                self.gen_expr(&args[0]);
+                            } else {
+                                self.emit("0");
+                            }
+                            self.emit(")");
+                            return;
+                        }
+                        "hstack" => {
+                            self.emit("reox_hstack(");
+                            if !args.is_empty() {
+                                self.gen_expr(&args[0]);
+                            } else {
+                                self.emit("0");
+                            }
+                            self.emit(")");
+                            return;
+                        }
+                        "window" => {
+                            self.emit("reox_window_create(");
+                            for (i, arg) in args.iter().enumerate() {
+                                if i > 0 { self.emit(", "); }
+                                self.gen_expr(arg);
+                            }
+                            self.emit(")");
+                            return;
+                        }
+                        // Theme colors -> emit directly
+                        "color_primary" => { self.emit("(rx_color){0, 122, 255, 255}"); return; }
+                        "color_secondary" => { self.emit("(rx_color){88, 86, 214, 255}"); return; }
+                        "color_success" => { self.emit("(rx_color){52, 199, 89, 255}"); return; }
+                        "color_warning" => { self.emit("(rx_color){255, 149, 0, 255}"); return; }
+                        "color_danger" => { self.emit("(rx_color){255, 59, 48, 255}"); return; }
+                        "color_background" => { self.emit("(rx_color){28, 28, 30, 255}"); return; }
+                        "color_surface" => { self.emit("(rx_color){44, 44, 46, 255}"); return; }
+                        "color_text" => { self.emit("(rx_color){255, 255, 255, 255}"); return; }
+                        // Standard function - emit as-is
+                        _ => {}
+                    }
+                }
+                // Default: emit as regular function call
                 self.gen_expr(callee);
                 self.emit("(");
                 for (i, arg) in args.iter().enumerate() {
@@ -537,6 +656,14 @@ impl CodeGen {
                 self.gen_expr(operand);
                 self.emit(")");
             }
+            Expr::Range(start, end, _) => {
+                // Runtime call to create array from range
+                self.emit("rx_range(");
+                self.gen_expr(start);
+                self.emit(", ");
+                self.gen_expr(end);
+                self.emit(")");
+            }
         }
     }