#moon_wesl

• ModulePath for module naming and relative import semantics
• Resolver for loading source from any backing store
• EscapeMangler for turning module-local names into emitted global symbols
• CompileOptions for import resolution, stripping, lowering, and feature flags
• compile(...) and Wesl::compile(...) as the main entry points

#Features

• Resolves WESL import statements across modules
• Supports @publish import ... re-exports
• Evaluates @if(...), @else if (...), and @else conditional blocks
• Strips unused declarations, rooted at shader entry points or explicit keep lists
• Optionally lowers top-level alias and const declarations into plain emitted code
• Delegates official WGSL parsing and semantic validation of emitted source to Milky2018/wgsl; WESL itself owns only extension and assembly semantics
• Lets callers provide source code from memory, files, asset systems, or editor buffers through the Resolver trait

#Install

moon add Milky2018/moon_wesl

import {
  "Milky2018/moon_wesl",
}

#Quick Start

///|
test {
  let resolver = @moon_wesl.VirtualResolver::new()
  let util_path = @moon_wesl.ModulePath::from_path("/shaders/util.wesl")
  let root_path = @moon_wesl.ModulePath::from_path(
    "/shaders/custom_material.wesl",
  )

  resolver.add_module(
    util_path, "fn make_polka_dots(v: f32) -> f32 {\n  @if(PARTY_MODE) {\n    return v * 2.0;\n  } @else {\n    return v;\n  }\n}\n",
  )
  resolver.add_module(
    root_path, "import super::util::make_polka_dots;\n@fragment\nfn fragment(v: f32) -> f32 {\n  return make_polka_dots(v);\n}\n",
  )

  let features = @moon_wesl.Features::default()
  features.set_feature("PARTY_MODE", Enable)
  let options = {
    ..@moon_wesl.CompileOptions::default(),
    lower: true,
    features,
  }

  let result = try! @moon_wesl.compile(
    root_path,
    resolver,
    @moon_wesl.EscapeMangler::default(),
    options,
  )
  inspect(result.to_string().contains("@fragment"), content="true")
}

#Migration from 0.1.x

#Core Concepts

#ModulePath

• ModulePath::from_path("/shaders/custom_material.wesl") -> package::shaders::custom_material
• ModulePath::from_path("./util.wesl") -> self::util
• ModulePath::from_path("../shared/noise.wesl") -> super::shared::noise
• parse_module_path("package::shaders::util")

#Resolver

///|
pub(open) trait Resolver {
  fn resolve_source(Self, @moon_wesl.ModulePath) -> String raise @moon_wesl.ResolveError
}

#EscapeMangler

#Compilation Model

1. Load the root module through Resolver and parse top-level items and imports.
2. Recursively resolve imports and compute the reachable declaration set.
3. Emit modules in dependency order while rewriting imported identifiers to mangled global names.
4. Optionally lower top-level alias and const declarations when lower is true.

• functions annotated with @fragment, @vertex, or @compute
• any declarations named by the keep field
• all root declarations if keep_root is true

#CompileOptions

• imports = true
• condcomp = true
• strip = true
• lower = false
• lazy_resolution = true
• mangle_root = false
• keep_root = false
• keep = None
• features = {}

#Re-exports and Visibility

• import super::util::foo; makes foo available only inside the current module
• @publish import super::util::foo; allows other modules to import foo through the current module

#Errors

• ModulePathParseError for invalid textual module paths
• ResolveError for source-loading failures
• WeslCompileError for compile-time failures, including:
  • parse errors in WESL source
  • invalid conditional expressions
  • duplicate local declarations or import aliases
  • missing declarations in imported modules
  • private re-export attempts

#Scope and Current Behavior

• module-path resolution
• import parsing
• public re-export handling
• conditional compilation
• reachability-based stripping
• symbol mangling
• simple lowering of top-level aliases and constants
• scalar/vector EvalResult::to_buffer() for i32, u32, and f32
• minimal CPU execution for simple entrypoints, including scalar pipeline overrides, builtin and user-defined @location input parameters, struct field reads, vector swizzles, vector/array/matrix indexing, basic if / else and while control flow, for loops, loop/continuing/break if, switch selection, scalar/vector/struct/array/matrix resource buffers, and runtime array length queries, field/index/component storage resource writeback, and return buffers
• filesystem package scanning and artifact generation

#Design Constraints

• no runtime dependency on graphics backends or platform SDKs
• no requirement to embed or link wgpu, GPU drivers, window systems, or engine-specific runtimes
• no platform-coupled execution model in the core package

#Repository Layout

• compile.mbt: main compiler pipeline
• path.mbt: module-path parsing and joining
• resolve.mbt: Resolver abstraction and VirtualResolver
• mangle.mbt: emitted-name mangling
• wesl_test.mbt: black-box tests covering the public API

#Development

moon test -v
moon info
moon fmt

#License