Add Julia feature requests and roadmap update

FEATURE_REQUESTS.md

@@ -108,3 +108,26 @@
 - Packaging format and plugin discovery/loading
 - Example integration with a Rust binary or shared library
 
+## Julia Language Support (Full Pipeline) — PROPOSED
+
+**Goal:** Add full Julia support (parse, AST, generate, project, and annotations) to Whetstone.
+
+**Scope:**
+- Tree-sitter Julia parser integration
+- Julia AST mapping to SemAnno concepts
+- Julia generator with annotation-aware output
+- Cross-language projection to/from Julia
+- Tests: parse/generate round-trip, annotation preservation, projection matrix coverage
+
+---
+
+## Julia ML Projection Layer — PROPOSED
+
+**Goal:** Map common Python ML/Numerical APIs to Julia equivalents while preserving optimization intent.
+
+**Scope:**
+- API mapping table (NumPy/Pandas/Torch core calls ? Julia equivalents)
+- Semantic tags for numerical/tensor operations
+- Fallback interop for unmapped calls (PyCall/JuliaCall)
+- Dual projections: clean surface Julia + preserved optimization annotations
+

LANGUAGE_SUPPORT_ROADMAP.md

@@ -26,37 +26,42 @@ complexity. It is intended for future sprint planning (not tied to Sprint 8).
    - Complexity: Medium (interop with Java).
 
 ### Phase B: Semantic-First Languages (Best AST Fit)
-4. Common Lisp / Scheme
+4. Julia
+   - Rationale: Homoiconic macros + high-performance numeric core; strong AST fit.
+   - Complexity: Medium (metaprogramming + multiple dispatch semantics).
+   - Notes: Prioritize ML/numerical API mappings after core language support.
+
+5. Common Lisp / Scheme
    - Rationale: Homoiconic AST, macros, direct mapping to transformations.
    - Complexity: Medium (macro system and evaluation model).
 
-5. OCaml / F#
+6. OCaml / F#
    - Rationale: Algebraic data types, pattern matching, strong typing.
    - Complexity: Medium (type system mapping).
 
-6. Haskell
+7. Haskell
    - Rationale: Pure FP, strong types; great for semantic transformations.
    - Complexity: High (typeclass system, laziness).
 
 ### Phase C: Concurrency/Logic Models
-7. Erlang / Elixir
+8. Erlang / Elixir
    - Rationale: Actor model, supervision trees; great for explicit execution annotations.
    - Complexity: High (message passing semantics).
 
-8. Prolog
+9. Prolog
    - Rationale: Declarative semantics, unification; fits AST reasoning.
    - Complexity: High (search/backtracking model).
 
 ### Phase D: Long-Tail, Specialized
-9. Swift
+10. Swift
    - Rationale: ARC semantics align with annotations; Apple ecosystem.
    - Complexity: High (toolchain + platform APIs).
 
-10. Ruby / Lua
+11. Ruby / Lua
    - Rationale: Dynamic languages with distinct semantics.
    - Complexity: Medium.
 
-11. Dart
+12. Dart
    - Rationale: Flutter ecosystem.
    - Complexity: Medium.