diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file
diff --git a/mill-iw-support/build.sc b/mill-iw-support/build.sc
new file mode 100644
index 0000000..5df80ae
--- /dev/null
+++ b/mill-iw-support/build.sc
@@ -0,0 +1,32 @@
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+import mill.scalalib.scalafmt._
+
+object `mill-iw-support` extends Cross[IWMillSupportModule]("2.13.16", "3.6.3")
+
+class IWMillSupportModule(val crossScalaVersion: String) extends CrossScalaModule with ScalafmtModule with PublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+
+  def pomSettings = PomSettings(
+    description = "Iterative Works Mill Support Library",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/mill-iw-support",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "mill-iw-support"),
+    developers = Seq(
+      Developer("mph", "Michal Přihoda", "https://github.com/iterative-works")
+    )
+  )
+
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::os-lib:0.9.3"
+  )
+
+  object test extends Tests with ScalafmtModule {
+    def ivyDeps = Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+    def testFramework = "utest.runner.Framework"
+  }
+}
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file
diff --git a/mill-iw-support/build.sc b/mill-iw-support/build.sc
new file mode 100644
index 0000000..5df80ae
--- /dev/null
+++ b/mill-iw-support/build.sc
@@ -0,0 +1,32 @@
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+import mill.scalalib.scalafmt._
+
+object `mill-iw-support` extends Cross[IWMillSupportModule]("2.13.16", "3.6.3")
+
+class IWMillSupportModule(val crossScalaVersion: String) extends CrossScalaModule with ScalafmtModule with PublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+
+  def pomSettings = PomSettings(
+    description = "Iterative Works Mill Support Library",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/mill-iw-support",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "mill-iw-support"),
+    developers = Seq(
+      Developer("mph", "Michal Přihoda", "https://github.com/iterative-works")
+    )
+  )
+
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::os-lib:0.9.3"
+  )
+
+  object test extends Tests with ScalafmtModule {
+    def ivyDeps = Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+    def testFramework = "utest.runner.Framework"
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/build.sc b/mill-iw-support/example/build.sc
new file mode 100644
index 0000000..5da77ab
--- /dev/null
+++ b/mill-iw-support/example/build.sc
@@ -0,0 +1,30 @@
+import mill._
+import mill.scalalib._
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+
+object example extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "Example Mill Project using IW Mill Support",
+    organization = "com.example",
+    url = "https://github.com/example/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("example", "example"),
+    developers = Seq(
+      Developer("developer", "Example Developer", "https://github.com/example")
+    )
+  )
+  
+  // Use centralized dependency versions and definitions
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO() ++ Agg(
+    IWMillDeps.zioJson,
+    IWMillDeps.tapirCore,
+    IWMillDeps.tapirZIO,
+    IWMillDeps.tapirZIOJson
+  )
+  
+  // Define test module extending IWTests
+  object test extends Tests with IWTests
+}
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file
diff --git a/mill-iw-support/build.sc b/mill-iw-support/build.sc
new file mode 100644
index 0000000..5df80ae
--- /dev/null
+++ b/mill-iw-support/build.sc
@@ -0,0 +1,32 @@
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+import mill.scalalib.scalafmt._
+
+object `mill-iw-support` extends Cross[IWMillSupportModule]("2.13.16", "3.6.3")
+
+class IWMillSupportModule(val crossScalaVersion: String) extends CrossScalaModule with ScalafmtModule with PublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+
+  def pomSettings = PomSettings(
+    description = "Iterative Works Mill Support Library",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/mill-iw-support",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "mill-iw-support"),
+    developers = Seq(
+      Developer("mph", "Michal Přihoda", "https://github.com/iterative-works")
+    )
+  )
+
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::os-lib:0.9.3"
+  )
+
+  object test extends Tests with ScalafmtModule {
+    def ivyDeps = Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+    def testFramework = "utest.runner.Framework"
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/build.sc b/mill-iw-support/example/build.sc
new file mode 100644
index 0000000..5da77ab
--- /dev/null
+++ b/mill-iw-support/example/build.sc
@@ -0,0 +1,30 @@
+import mill._
+import mill.scalalib._
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+
+object example extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "Example Mill Project using IW Mill Support",
+    organization = "com.example",
+    url = "https://github.com/example/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("example", "example"),
+    developers = Seq(
+      Developer("developer", "Example Developer", "https://github.com/example")
+    )
+  )
+  
+  // Use centralized dependency versions and definitions
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO() ++ Agg(
+    IWMillDeps.zioJson,
+    IWMillDeps.tapirCore,
+    IWMillDeps.tapirZIO,
+    IWMillDeps.tapirZIOJson
+  )
+  
+  // Define test module extending IWTests
+  object test extends Tests with IWTests
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/src/Example.scala b/mill-iw-support/example/src/Example.scala
new file mode 100644
index 0000000..aa28980
--- /dev/null
+++ b/mill-iw-support/example/src/Example.scala
@@ -0,0 +1,27 @@
+package example
+
+import zio._
+import zio.json._
+
+// Simple example class
+case class User(id: String, name: String, email: String)
+
+object User {
+  // JSON codecs using ZIO JSON
+  implicit val encoder: JsonEncoder[User] = DeriveJsonEncoder.gen[User]
+  implicit val decoder: JsonDecoder[User] = DeriveJsonDecoder.gen[User]
+}
+
+object Example extends ZIOAppDefault {
+  
+  val program = for {
+    _ <- Console.printLine("Starting example application")
+    user = User("1", "John Doe", "john@example.com")
+    json <- ZIO.succeed(user.toJson)
+    _ <- Console.printLine(s"User as JSON: $json")
+    parsed <- ZIO.fromEither(json.fromJson[User])
+    _ <- Console.printLine(s"Parsed user: $parsed")
+  } yield ()
+  
+  def run = program
+}
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file
diff --git a/mill-iw-support/build.sc b/mill-iw-support/build.sc
new file mode 100644
index 0000000..5df80ae
--- /dev/null
+++ b/mill-iw-support/build.sc
@@ -0,0 +1,32 @@
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+import mill.scalalib.scalafmt._
+
+object `mill-iw-support` extends Cross[IWMillSupportModule]("2.13.16", "3.6.3")
+
+class IWMillSupportModule(val crossScalaVersion: String) extends CrossScalaModule with ScalafmtModule with PublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+
+  def pomSettings = PomSettings(
+    description = "Iterative Works Mill Support Library",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/mill-iw-support",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "mill-iw-support"),
+    developers = Seq(
+      Developer("mph", "Michal Přihoda", "https://github.com/iterative-works")
+    )
+  )
+
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::os-lib:0.9.3"
+  )
+
+  object test extends Tests with ScalafmtModule {
+    def ivyDeps = Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+    def testFramework = "utest.runner.Framework"
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/build.sc b/mill-iw-support/example/build.sc
new file mode 100644
index 0000000..5da77ab
--- /dev/null
+++ b/mill-iw-support/example/build.sc
@@ -0,0 +1,30 @@
+import mill._
+import mill.scalalib._
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+
+object example extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "Example Mill Project using IW Mill Support",
+    organization = "com.example",
+    url = "https://github.com/example/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("example", "example"),
+    developers = Seq(
+      Developer("developer", "Example Developer", "https://github.com/example")
+    )
+  )
+  
+  // Use centralized dependency versions and definitions
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO() ++ Agg(
+    IWMillDeps.zioJson,
+    IWMillDeps.tapirCore,
+    IWMillDeps.tapirZIO,
+    IWMillDeps.tapirZIOJson
+  )
+  
+  // Define test module extending IWTests
+  object test extends Tests with IWTests
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/src/Example.scala b/mill-iw-support/example/src/Example.scala
new file mode 100644
index 0000000..aa28980
--- /dev/null
+++ b/mill-iw-support/example/src/Example.scala
@@ -0,0 +1,27 @@
+package example
+
+import zio._
+import zio.json._
+
+// Simple example class
+case class User(id: String, name: String, email: String)
+
+object User {
+  // JSON codecs using ZIO JSON
+  implicit val encoder: JsonEncoder[User] = DeriveJsonEncoder.gen[User]
+  implicit val decoder: JsonDecoder[User] = DeriveJsonDecoder.gen[User]
+}
+
+object Example extends ZIOAppDefault {
+  
+  val program = for {
+    _ <- Console.printLine("Starting example application")
+    user = User("1", "John Doe", "john@example.com")
+    json <- ZIO.succeed(user.toJson)
+    _ <- Console.printLine(s"User as JSON: $json")
+    parsed <- ZIO.fromEither(json.fromJson[User])
+    _ <- Console.printLine(s"Parsed user: $parsed")
+  } yield ()
+  
+  def run = program
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/test/src/ExampleTest.scala b/mill-iw-support/example/test/src/ExampleTest.scala
new file mode 100644
index 0000000..20f0c06
--- /dev/null
+++ b/mill-iw-support/example/test/src/ExampleTest.scala
@@ -0,0 +1,27 @@
+package example
+
+import utest._
+import zio._
+import zio.json._
+import zio.test._
+import zio.test.Assertion._
+
+object ExampleTest extends TestSuite {
+  val tests = Tests {
+    test("User JSON serialization") {
+      val user = User("1", "John Doe", "john@example.com")
+      val json = user.toJson
+      val expected = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      
+      assert(json == expected)
+    }
+    
+    test("User JSON deserialization") {
+      val json = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      val parsed = json.fromJson[User]
+      val expected = User("1", "John Doe", "john@example.com")
+      
+      assert(parsed == Right(expected))
+    }
+  }
+}
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file
diff --git a/mill-iw-support/build.sc b/mill-iw-support/build.sc
new file mode 100644
index 0000000..5df80ae
--- /dev/null
+++ b/mill-iw-support/build.sc
@@ -0,0 +1,32 @@
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+import mill.scalalib.scalafmt._
+
+object `mill-iw-support` extends Cross[IWMillSupportModule]("2.13.16", "3.6.3")
+
+class IWMillSupportModule(val crossScalaVersion: String) extends CrossScalaModule with ScalafmtModule with PublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+
+  def pomSettings = PomSettings(
+    description = "Iterative Works Mill Support Library",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/mill-iw-support",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "mill-iw-support"),
+    developers = Seq(
+      Developer("mph", "Michal Přihoda", "https://github.com/iterative-works")
+    )
+  )
+
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::os-lib:0.9.3"
+  )
+
+  object test extends Tests with ScalafmtModule {
+    def ivyDeps = Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+    def testFramework = "utest.runner.Framework"
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/build.sc b/mill-iw-support/example/build.sc
new file mode 100644
index 0000000..5da77ab
--- /dev/null
+++ b/mill-iw-support/example/build.sc
@@ -0,0 +1,30 @@
+import mill._
+import mill.scalalib._
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+
+object example extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "Example Mill Project using IW Mill Support",
+    organization = "com.example",
+    url = "https://github.com/example/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("example", "example"),
+    developers = Seq(
+      Developer("developer", "Example Developer", "https://github.com/example")
+    )
+  )
+  
+  // Use centralized dependency versions and definitions
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO() ++ Agg(
+    IWMillDeps.zioJson,
+    IWMillDeps.tapirCore,
+    IWMillDeps.tapirZIO,
+    IWMillDeps.tapirZIOJson
+  )
+  
+  // Define test module extending IWTests
+  object test extends Tests with IWTests
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/src/Example.scala b/mill-iw-support/example/src/Example.scala
new file mode 100644
index 0000000..aa28980
--- /dev/null
+++ b/mill-iw-support/example/src/Example.scala
@@ -0,0 +1,27 @@
+package example
+
+import zio._
+import zio.json._
+
+// Simple example class
+case class User(id: String, name: String, email: String)
+
+object User {
+  // JSON codecs using ZIO JSON
+  implicit val encoder: JsonEncoder[User] = DeriveJsonEncoder.gen[User]
+  implicit val decoder: JsonDecoder[User] = DeriveJsonDecoder.gen[User]
+}
+
+object Example extends ZIOAppDefault {
+  
+  val program = for {
+    _ <- Console.printLine("Starting example application")
+    user = User("1", "John Doe", "john@example.com")
+    json <- ZIO.succeed(user.toJson)
+    _ <- Console.printLine(s"User as JSON: $json")
+    parsed <- ZIO.fromEither(json.fromJson[User])
+    _ <- Console.printLine(s"Parsed user: $parsed")
+  } yield ()
+  
+  def run = program
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/test/src/ExampleTest.scala b/mill-iw-support/example/test/src/ExampleTest.scala
new file mode 100644
index 0000000..20f0c06
--- /dev/null
+++ b/mill-iw-support/example/test/src/ExampleTest.scala
@@ -0,0 +1,27 @@
+package example
+
+import utest._
+import zio._
+import zio.json._
+import zio.test._
+import zio.test.Assertion._
+
+object ExampleTest extends TestSuite {
+  val tests = Tests {
+    test("User JSON serialization") {
+      val user = User("1", "John Doe", "john@example.com")
+      val json = user.toJson
+      val expected = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      
+      assert(json == expected)
+    }
+    
+    test("User JSON deserialization") {
+      val json = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      val parsed = json.fromJson[User]
+      val expected = User("1", "John Doe", "john@example.com")
+      
+      assert(parsed == Right(expected))
+    }
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala
new file mode 100644
index 0000000..e21af78
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala
@@ -0,0 +1,78 @@
+package works.iterative.mill
+
+import mill.api.Loose
+import mill.scalalib.Dep
+
+/**
+ * Standardized dependency management for Iterative Works projects using Mill.
+ * This object provides methods to get dependencies with proper versioning.
+ * 
+ * All versions are centralized in [[IWMillVersions]].
+ */
+object IWMillDeps {
+  import IWMillVersions as V
+
+  // ZIO Core
+  def zio = ivy"dev.zio::zio:${V.zio}"
+  def zioTest = ivy"dev.zio::zio-test:${V.zio}"
+  def zioTestSbt = ivy"dev.zio::zio-test-sbt:${V.zio}"
+  def zioStreams = ivy"dev.zio::zio-streams:${V.zio}"
+
+  // ZIO Extensions
+  def zioConfig = ivy"dev.zio::zio-config:${V.zioConfig}"
+  def zioConfigTypesafe = ivy"dev.zio::zio-config-typesafe:${V.zioConfig}"
+  def zioConfigMagnolia = ivy"dev.zio::zio-config-magnolia:${V.zioConfig}"
+  def zioJson = ivy"dev.zio::zio-json:${V.zioJson}"
+  def zioLogging = ivy"dev.zio::zio-logging:${V.zioLogging}"
+  def zioLoggingSlf4j = ivy"dev.zio::zio-logging-slf4j:${V.zioLogging}"
+  def zioPrelude = ivy"dev.zio::zio-prelude:${V.zioPrelude}"
+  def zioInteropCats = ivy"dev.zio::zio-interop-cats:${V.zioInteropCats}"
+  def zioInteropReactiveStreams = ivy"dev.zio::zio-interop-reactivestreams:${V.zioInteropReactiveStreams}"
+  def zioNIO = ivy"dev.zio::zio-nio:${V.zioNIO}"
+  def zioCli = ivy"dev.zio::zio-cli:${V.zioCli}"
+  def zioSchema = ivy"dev.zio::zio-schema:${V.zioSchema}"
+  def zioSchemaDerivation = ivy"dev.zio::zio-schema-derivation:${V.zioSchema}"
+
+  // Helper methods for ZIO
+  def useZIO(): Loose.Agg[Dep] = Loose.Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+
+  def useZIOJson: Loose.Agg[Dep] = Loose.Agg(
+    zioJson
+  )
+
+  def useZIOAll(): Loose.Agg[Dep] = useZIO() ++ Loose.Agg(
+    zioStreams,
+    zioConfig,
+    zioConfigTypesafe,
+    zioConfigMagnolia,
+    zioLogging,
+    zioPrelude
+  ) ++ useZIOJson
+
+  // Database
+  def quill = ivy"io.getquill::quill-jdbc-zio:${V.quill}"
+  def magnum = ivy"com.augustnagro::magnum_3:${V.magnum}"
+  def magnumZIO = ivy"com.augustnagro::magnumzio_3:${V.magnum}"
+  def magnumPG = ivy"com.augustnagro::magnumpg_3:${V.magnum}"
+
+  // HTTP
+  def tapirCore = ivy"com.softwaremill.sttp.tapir::tapir-core:${V.tapir}"
+  def tapirZIO = ivy"com.softwaremill.sttp.tapir::tapir-zio:${V.tapir}"
+  def tapirZIOJson = ivy"com.softwaremill.sttp.tapir::tapir-json-zio:${V.tapir}"
+  
+  // UI/Frontend
+  def scalatags = ivy"com.lihaoyi::scalatags:${V.scalatags}"
+  def laminar = ivy"com.raquo::laminar:${V.laminar}"
+  def waypoint = ivy"com.raquo::waypoint:${V.waypoint}"
+  def urlDsl = ivy"be.doeraene::url-dsl:${V.urlDsl}"
+  
+  // Testing
+  def scalaTest = ivy"org.scalatest::scalatest:${V.scalaTest}"
+  
+  // Logging
+  def logbackClassic = ivy"ch.qos.logback:logback-classic:${V.logbackClassic}"
+}
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file
diff --git a/mill-iw-support/build.sc b/mill-iw-support/build.sc
new file mode 100644
index 0000000..5df80ae
--- /dev/null
+++ b/mill-iw-support/build.sc
@@ -0,0 +1,32 @@
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+import mill.scalalib.scalafmt._
+
+object `mill-iw-support` extends Cross[IWMillSupportModule]("2.13.16", "3.6.3")
+
+class IWMillSupportModule(val crossScalaVersion: String) extends CrossScalaModule with ScalafmtModule with PublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+
+  def pomSettings = PomSettings(
+    description = "Iterative Works Mill Support Library",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/mill-iw-support",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "mill-iw-support"),
+    developers = Seq(
+      Developer("mph", "Michal Přihoda", "https://github.com/iterative-works")
+    )
+  )
+
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::os-lib:0.9.3"
+  )
+
+  object test extends Tests with ScalafmtModule {
+    def ivyDeps = Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+    def testFramework = "utest.runner.Framework"
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/build.sc b/mill-iw-support/example/build.sc
new file mode 100644
index 0000000..5da77ab
--- /dev/null
+++ b/mill-iw-support/example/build.sc
@@ -0,0 +1,30 @@
+import mill._
+import mill.scalalib._
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+
+object example extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "Example Mill Project using IW Mill Support",
+    organization = "com.example",
+    url = "https://github.com/example/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("example", "example"),
+    developers = Seq(
+      Developer("developer", "Example Developer", "https://github.com/example")
+    )
+  )
+  
+  // Use centralized dependency versions and definitions
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO() ++ Agg(
+    IWMillDeps.zioJson,
+    IWMillDeps.tapirCore,
+    IWMillDeps.tapirZIO,
+    IWMillDeps.tapirZIOJson
+  )
+  
+  // Define test module extending IWTests
+  object test extends Tests with IWTests
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/src/Example.scala b/mill-iw-support/example/src/Example.scala
new file mode 100644
index 0000000..aa28980
--- /dev/null
+++ b/mill-iw-support/example/src/Example.scala
@@ -0,0 +1,27 @@
+package example
+
+import zio._
+import zio.json._
+
+// Simple example class
+case class User(id: String, name: String, email: String)
+
+object User {
+  // JSON codecs using ZIO JSON
+  implicit val encoder: JsonEncoder[User] = DeriveJsonEncoder.gen[User]
+  implicit val decoder: JsonDecoder[User] = DeriveJsonDecoder.gen[User]
+}
+
+object Example extends ZIOAppDefault {
+  
+  val program = for {
+    _ <- Console.printLine("Starting example application")
+    user = User("1", "John Doe", "john@example.com")
+    json <- ZIO.succeed(user.toJson)
+    _ <- Console.printLine(s"User as JSON: $json")
+    parsed <- ZIO.fromEither(json.fromJson[User])
+    _ <- Console.printLine(s"Parsed user: $parsed")
+  } yield ()
+  
+  def run = program
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/test/src/ExampleTest.scala b/mill-iw-support/example/test/src/ExampleTest.scala
new file mode 100644
index 0000000..20f0c06
--- /dev/null
+++ b/mill-iw-support/example/test/src/ExampleTest.scala
@@ -0,0 +1,27 @@
+package example
+
+import utest._
+import zio._
+import zio.json._
+import zio.test._
+import zio.test.Assertion._
+
+object ExampleTest extends TestSuite {
+  val tests = Tests {
+    test("User JSON serialization") {
+      val user = User("1", "John Doe", "john@example.com")
+      val json = user.toJson
+      val expected = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      
+      assert(json == expected)
+    }
+    
+    test("User JSON deserialization") {
+      val json = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      val parsed = json.fromJson[User]
+      val expected = User("1", "John Doe", "john@example.com")
+      
+      assert(parsed == Right(expected))
+    }
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala
new file mode 100644
index 0000000..e21af78
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala
@@ -0,0 +1,78 @@
+package works.iterative.mill
+
+import mill.api.Loose
+import mill.scalalib.Dep
+
+/**
+ * Standardized dependency management for Iterative Works projects using Mill.
+ * This object provides methods to get dependencies with proper versioning.
+ * 
+ * All versions are centralized in [[IWMillVersions]].
+ */
+object IWMillDeps {
+  import IWMillVersions as V
+
+  // ZIO Core
+  def zio = ivy"dev.zio::zio:${V.zio}"
+  def zioTest = ivy"dev.zio::zio-test:${V.zio}"
+  def zioTestSbt = ivy"dev.zio::zio-test-sbt:${V.zio}"
+  def zioStreams = ivy"dev.zio::zio-streams:${V.zio}"
+
+  // ZIO Extensions
+  def zioConfig = ivy"dev.zio::zio-config:${V.zioConfig}"
+  def zioConfigTypesafe = ivy"dev.zio::zio-config-typesafe:${V.zioConfig}"
+  def zioConfigMagnolia = ivy"dev.zio::zio-config-magnolia:${V.zioConfig}"
+  def zioJson = ivy"dev.zio::zio-json:${V.zioJson}"
+  def zioLogging = ivy"dev.zio::zio-logging:${V.zioLogging}"
+  def zioLoggingSlf4j = ivy"dev.zio::zio-logging-slf4j:${V.zioLogging}"
+  def zioPrelude = ivy"dev.zio::zio-prelude:${V.zioPrelude}"
+  def zioInteropCats = ivy"dev.zio::zio-interop-cats:${V.zioInteropCats}"
+  def zioInteropReactiveStreams = ivy"dev.zio::zio-interop-reactivestreams:${V.zioInteropReactiveStreams}"
+  def zioNIO = ivy"dev.zio::zio-nio:${V.zioNIO}"
+  def zioCli = ivy"dev.zio::zio-cli:${V.zioCli}"
+  def zioSchema = ivy"dev.zio::zio-schema:${V.zioSchema}"
+  def zioSchemaDerivation = ivy"dev.zio::zio-schema-derivation:${V.zioSchema}"
+
+  // Helper methods for ZIO
+  def useZIO(): Loose.Agg[Dep] = Loose.Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+
+  def useZIOJson: Loose.Agg[Dep] = Loose.Agg(
+    zioJson
+  )
+
+  def useZIOAll(): Loose.Agg[Dep] = useZIO() ++ Loose.Agg(
+    zioStreams,
+    zioConfig,
+    zioConfigTypesafe,
+    zioConfigMagnolia,
+    zioLogging,
+    zioPrelude
+  ) ++ useZIOJson
+
+  // Database
+  def quill = ivy"io.getquill::quill-jdbc-zio:${V.quill}"
+  def magnum = ivy"com.augustnagro::magnum_3:${V.magnum}"
+  def magnumZIO = ivy"com.augustnagro::magnumzio_3:${V.magnum}"
+  def magnumPG = ivy"com.augustnagro::magnumpg_3:${V.magnum}"
+
+  // HTTP
+  def tapirCore = ivy"com.softwaremill.sttp.tapir::tapir-core:${V.tapir}"
+  def tapirZIO = ivy"com.softwaremill.sttp.tapir::tapir-zio:${V.tapir}"
+  def tapirZIOJson = ivy"com.softwaremill.sttp.tapir::tapir-json-zio:${V.tapir}"
+  
+  // UI/Frontend
+  def scalatags = ivy"com.lihaoyi::scalatags:${V.scalatags}"
+  def laminar = ivy"com.raquo::laminar:${V.laminar}"
+  def waypoint = ivy"com.raquo::waypoint:${V.waypoint}"
+  def urlDsl = ivy"be.doeraene::url-dsl:${V.urlDsl}"
+  
+  // Testing
+  def scalaTest = ivy"org.scalatest::scalatest:${V.scalaTest}"
+  
+  // Logging
+  def logbackClassic = ivy"ch.qos.logback:logback-classic:${V.logbackClassic}"
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala
new file mode 100644
index 0000000..4e3150a
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala
@@ -0,0 +1,55 @@
+package works.iterative.mill
+
+/**
+ * Centralized version management for Iterative Works projects using Mill.
+ * This object contains all library versions used across projects.
+ * 
+ * Update this object to bump versions for all projects.
+ */
+object IWMillVersions {
+  // ZIO Ecosystem
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  val zioCli = "0.7.0"
+  val zioInteropCats = "23.1.0.3"
+  val zioInteropReactiveStreams = "2.0.2"
+  val zioJson = "0.7.36"
+  val zioLogging = "2.5.0"
+  val zioNIO = "2.0.2"
+  val zioPrelude = "1.0.0-RC39"
+  val zioQuery = "0.7.6"
+  val zioSchema = "1.6.3"
+
+  // Akka Ecosystem
+  val akka = "2.6.18"
+  val akkaHttp = "10.4.0"
+
+  // Other Libraries
+  val cats = "2.13.0"
+  val caliban = "2.9.2"
+  val chimney = "1.7.3"
+  val ducktape = "0.2.7"
+  val elastic4s = "7.12.4"
+  val http4s = "0.23.30"
+  val http4sBlaze = "0.23.17"
+  val http4sPac4J = "5.0.0"
+  val laminar = "17.2.0"
+  val laminext = "0.17.0"
+  val logbackClassic = "1.5.17"
+  val magnum = "2.0.0-M1"
+  val pac4j = "6.0.3"
+  val play = "2.8.18"
+  val playJson = "2.9.3"
+  val quill = "4.8.6"
+  val scalaJsMacroTaskExecutor = "1.1.1"
+  val scalaJsJavaSecureRandom = "1.0.0"
+  val scalatags = "0.13.1"
+  val scalaTest = "3.2.19"
+  val slick = "3.3.3"
+  val sttpClient3 = "3.10.3"
+  val sttpClient4 = "4.0.0-RC1"
+  val support = "1.7.0"
+  val tapir = "1.11.16"
+  val urlDsl = "0.7.0"
+  val waypoint = "9.0.0"
+}
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file
diff --git a/mill-iw-support/build.sc b/mill-iw-support/build.sc
new file mode 100644
index 0000000..5df80ae
--- /dev/null
+++ b/mill-iw-support/build.sc
@@ -0,0 +1,32 @@
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+import mill.scalalib.scalafmt._
+
+object `mill-iw-support` extends Cross[IWMillSupportModule]("2.13.16", "3.6.3")
+
+class IWMillSupportModule(val crossScalaVersion: String) extends CrossScalaModule with ScalafmtModule with PublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+
+  def pomSettings = PomSettings(
+    description = "Iterative Works Mill Support Library",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/mill-iw-support",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "mill-iw-support"),
+    developers = Seq(
+      Developer("mph", "Michal Přihoda", "https://github.com/iterative-works")
+    )
+  )
+
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::os-lib:0.9.3"
+  )
+
+  object test extends Tests with ScalafmtModule {
+    def ivyDeps = Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+    def testFramework = "utest.runner.Framework"
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/build.sc b/mill-iw-support/example/build.sc
new file mode 100644
index 0000000..5da77ab
--- /dev/null
+++ b/mill-iw-support/example/build.sc
@@ -0,0 +1,30 @@
+import mill._
+import mill.scalalib._
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+
+object example extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "Example Mill Project using IW Mill Support",
+    organization = "com.example",
+    url = "https://github.com/example/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("example", "example"),
+    developers = Seq(
+      Developer("developer", "Example Developer", "https://github.com/example")
+    )
+  )
+  
+  // Use centralized dependency versions and definitions
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO() ++ Agg(
+    IWMillDeps.zioJson,
+    IWMillDeps.tapirCore,
+    IWMillDeps.tapirZIO,
+    IWMillDeps.tapirZIOJson
+  )
+  
+  // Define test module extending IWTests
+  object test extends Tests with IWTests
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/src/Example.scala b/mill-iw-support/example/src/Example.scala
new file mode 100644
index 0000000..aa28980
--- /dev/null
+++ b/mill-iw-support/example/src/Example.scala
@@ -0,0 +1,27 @@
+package example
+
+import zio._
+import zio.json._
+
+// Simple example class
+case class User(id: String, name: String, email: String)
+
+object User {
+  // JSON codecs using ZIO JSON
+  implicit val encoder: JsonEncoder[User] = DeriveJsonEncoder.gen[User]
+  implicit val decoder: JsonDecoder[User] = DeriveJsonDecoder.gen[User]
+}
+
+object Example extends ZIOAppDefault {
+  
+  val program = for {
+    _ <- Console.printLine("Starting example application")
+    user = User("1", "John Doe", "john@example.com")
+    json <- ZIO.succeed(user.toJson)
+    _ <- Console.printLine(s"User as JSON: $json")
+    parsed <- ZIO.fromEither(json.fromJson[User])
+    _ <- Console.printLine(s"Parsed user: $parsed")
+  } yield ()
+  
+  def run = program
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/test/src/ExampleTest.scala b/mill-iw-support/example/test/src/ExampleTest.scala
new file mode 100644
index 0000000..20f0c06
--- /dev/null
+++ b/mill-iw-support/example/test/src/ExampleTest.scala
@@ -0,0 +1,27 @@
+package example
+
+import utest._
+import zio._
+import zio.json._
+import zio.test._
+import zio.test.Assertion._
+
+object ExampleTest extends TestSuite {
+  val tests = Tests {
+    test("User JSON serialization") {
+      val user = User("1", "John Doe", "john@example.com")
+      val json = user.toJson
+      val expected = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      
+      assert(json == expected)
+    }
+    
+    test("User JSON deserialization") {
+      val json = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      val parsed = json.fromJson[User]
+      val expected = User("1", "John Doe", "john@example.com")
+      
+      assert(parsed == Right(expected))
+    }
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala
new file mode 100644
index 0000000..e21af78
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala
@@ -0,0 +1,78 @@
+package works.iterative.mill
+
+import mill.api.Loose
+import mill.scalalib.Dep
+
+/**
+ * Standardized dependency management for Iterative Works projects using Mill.
+ * This object provides methods to get dependencies with proper versioning.
+ * 
+ * All versions are centralized in [[IWMillVersions]].
+ */
+object IWMillDeps {
+  import IWMillVersions as V
+
+  // ZIO Core
+  def zio = ivy"dev.zio::zio:${V.zio}"
+  def zioTest = ivy"dev.zio::zio-test:${V.zio}"
+  def zioTestSbt = ivy"dev.zio::zio-test-sbt:${V.zio}"
+  def zioStreams = ivy"dev.zio::zio-streams:${V.zio}"
+
+  // ZIO Extensions
+  def zioConfig = ivy"dev.zio::zio-config:${V.zioConfig}"
+  def zioConfigTypesafe = ivy"dev.zio::zio-config-typesafe:${V.zioConfig}"
+  def zioConfigMagnolia = ivy"dev.zio::zio-config-magnolia:${V.zioConfig}"
+  def zioJson = ivy"dev.zio::zio-json:${V.zioJson}"
+  def zioLogging = ivy"dev.zio::zio-logging:${V.zioLogging}"
+  def zioLoggingSlf4j = ivy"dev.zio::zio-logging-slf4j:${V.zioLogging}"
+  def zioPrelude = ivy"dev.zio::zio-prelude:${V.zioPrelude}"
+  def zioInteropCats = ivy"dev.zio::zio-interop-cats:${V.zioInteropCats}"
+  def zioInteropReactiveStreams = ivy"dev.zio::zio-interop-reactivestreams:${V.zioInteropReactiveStreams}"
+  def zioNIO = ivy"dev.zio::zio-nio:${V.zioNIO}"
+  def zioCli = ivy"dev.zio::zio-cli:${V.zioCli}"
+  def zioSchema = ivy"dev.zio::zio-schema:${V.zioSchema}"
+  def zioSchemaDerivation = ivy"dev.zio::zio-schema-derivation:${V.zioSchema}"
+
+  // Helper methods for ZIO
+  def useZIO(): Loose.Agg[Dep] = Loose.Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+
+  def useZIOJson: Loose.Agg[Dep] = Loose.Agg(
+    zioJson
+  )
+
+  def useZIOAll(): Loose.Agg[Dep] = useZIO() ++ Loose.Agg(
+    zioStreams,
+    zioConfig,
+    zioConfigTypesafe,
+    zioConfigMagnolia,
+    zioLogging,
+    zioPrelude
+  ) ++ useZIOJson
+
+  // Database
+  def quill = ivy"io.getquill::quill-jdbc-zio:${V.quill}"
+  def magnum = ivy"com.augustnagro::magnum_3:${V.magnum}"
+  def magnumZIO = ivy"com.augustnagro::magnumzio_3:${V.magnum}"
+  def magnumPG = ivy"com.augustnagro::magnumpg_3:${V.magnum}"
+
+  // HTTP
+  def tapirCore = ivy"com.softwaremill.sttp.tapir::tapir-core:${V.tapir}"
+  def tapirZIO = ivy"com.softwaremill.sttp.tapir::tapir-zio:${V.tapir}"
+  def tapirZIOJson = ivy"com.softwaremill.sttp.tapir::tapir-json-zio:${V.tapir}"
+  
+  // UI/Frontend
+  def scalatags = ivy"com.lihaoyi::scalatags:${V.scalatags}"
+  def laminar = ivy"com.raquo::laminar:${V.laminar}"
+  def waypoint = ivy"com.raquo::waypoint:${V.waypoint}"
+  def urlDsl = ivy"be.doeraene::url-dsl:${V.urlDsl}"
+  
+  // Testing
+  def scalaTest = ivy"org.scalatest::scalatest:${V.scalaTest}"
+  
+  // Logging
+  def logbackClassic = ivy"ch.qos.logback:logback-classic:${V.logbackClassic}"
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala
new file mode 100644
index 0000000..4e3150a
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala
@@ -0,0 +1,55 @@
+package works.iterative.mill
+
+/**
+ * Centralized version management for Iterative Works projects using Mill.
+ * This object contains all library versions used across projects.
+ * 
+ * Update this object to bump versions for all projects.
+ */
+object IWMillVersions {
+  // ZIO Ecosystem
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  val zioCli = "0.7.0"
+  val zioInteropCats = "23.1.0.3"
+  val zioInteropReactiveStreams = "2.0.2"
+  val zioJson = "0.7.36"
+  val zioLogging = "2.5.0"
+  val zioNIO = "2.0.2"
+  val zioPrelude = "1.0.0-RC39"
+  val zioQuery = "0.7.6"
+  val zioSchema = "1.6.3"
+
+  // Akka Ecosystem
+  val akka = "2.6.18"
+  val akkaHttp = "10.4.0"
+
+  // Other Libraries
+  val cats = "2.13.0"
+  val caliban = "2.9.2"
+  val chimney = "1.7.3"
+  val ducktape = "0.2.7"
+  val elastic4s = "7.12.4"
+  val http4s = "0.23.30"
+  val http4sBlaze = "0.23.17"
+  val http4sPac4J = "5.0.0"
+  val laminar = "17.2.0"
+  val laminext = "0.17.0"
+  val logbackClassic = "1.5.17"
+  val magnum = "2.0.0-M1"
+  val pac4j = "6.0.3"
+  val play = "2.8.18"
+  val playJson = "2.9.3"
+  val quill = "4.8.6"
+  val scalaJsMacroTaskExecutor = "1.1.1"
+  val scalaJsJavaSecureRandom = "1.0.0"
+  val scalatags = "0.13.1"
+  val scalaTest = "3.2.19"
+  val slick = "3.3.3"
+  val sttpClient3 = "3.10.3"
+  val sttpClient4 = "4.0.0-RC1"
+  val support = "1.7.0"
+  val tapir = "1.11.16"
+  val urlDsl = "0.7.0"
+  val waypoint = "9.0.0"
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWPublishModule.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWPublishModule.scala
new file mode 100644
index 0000000..29a2df4
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWPublishModule.scala
@@ -0,0 +1,43 @@
+package works.iterative.mill
+
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+
+/**
+ * Standard publish module trait for Iterative Works projects using Mill.
+ * This trait sets up standard publishing configuration for IW Maven repositories.
+ */
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  /**
+   * Determines the repository URL based on version.
+   * - Snapshot versions go to the snapshots repository
+   * - Release versions go to the releases repository
+   */
+  def repositoryUrl: T[String] = T {
+    if (publishVersion().endsWith("-SNAPSHOT"))
+      "https://dig.iterative.works/maven/snapshots"
+    else
+      "https://dig.iterative.works/maven/releases"
+  }
+  
+  /**
+   * Configure publish credentials from environment variables.
+   */
+  def publishCredentials: T[PublishCredentials] = T {
+    val username = sys.env.getOrElse("IW_USERNAME", "")
+    val password = sys.env.getOrElse("IW_PASSWORD", "")
+    PublishCredentials("GitBucket Maven Repository", "dig.iterative.works", username, password)
+  }
+  
+  /**
+   * Configure publication to IW Maven repository.
+   */
+  def publishTo: T[Option[PublishRepository]] = T {
+    Some(PublishRepository(repositoryUrl(), publishCredentials()))
+  }
+}
\ No newline at end of file

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..37a1b89
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,24 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+- Build: `sbt compile`
+- Test: `sbt test`
+- Single test: `sbt "testOnly fully.qualified.TestName"`
+- Test specific method: `sbt "testOnly fully.qualified.TestName -- -t test_name"`
+- SBT plugin tests: `sbt scripted`
+- Run g8 template test: `sbt g8Test`
+- Check formatting: `sbt scalafmtCheck`
+- Format code: `sbt scalafmt`
+- Fix code style: `sbt scalafixAll`
+
+## Code Style
+- Scala 3 is primary (default 3.6.3)
+- 100 char line length, 4 space indentation
+- ZIO ecosystem is preferred
+- Use scalafmt (3.7.x) and scalafix (0.12.x)
+- Follow pure functional style with immutable data
+- Enable SemanticDB for tooling support
+- Prefer early-semver versioning
+- Centralize dependency versions in IWMaterialsVersions
\ No newline at end of file
diff --git a/change-requests/202501-mill.md b/change-requests/202501-mill.md
new file mode 100644
index 0000000..8e94674
--- /dev/null
+++ b/change-requests/202501-mill.md
@@ -0,0 +1,89 @@
+# Change Request #01/2025: Mill Build Tool Support
+
+**Date Created:** 02.04.2025
+**Author:** Claude
+
+## 1. Original Request
+
+Investigate using Mill as an alternative to SBT for Scala builds while maintaining our standardized approach to dependency management and project configuration.
+
+## 2. Change Specification
+
+### Overview
+Create Mill build tool support equivalent to our existing SBT infrastructure. This would enable us to use Mill as an alternative build tool while maintaining our standardized dependency management and project configuration approaches.
+
+### Motivation
+Mill offers several potential benefits over SBT:
+- Faster build times through aggressive caching and parallelism
+- Better IDE support with type-checked build files
+- Simpler configuration with fewer plugins needed
+- Easier extension with custom tasks
+- Cleaner syntax and more approachable learning curve
+
+### Scope
+1. Create an equivalent to IWMaterialsVersions for Mill
+2. Create an equivalent to IWMaterialsDeps for Mill
+3. Create an equivalent to IWScalaProjectPlugin for Mill
+4. Document how to configure publishing to IW Maven repositories
+5. Create examples showing migration from SBT to Mill
+
+## 3. Time Estimate and Timeline
+- Research & Planning: 1 week
+- Implementation of core components: 2 weeks
+- Documentation and examples: 1 week
+- Testing with existing projects: 1 week
+
+Total: 5 weeks
+
+## 4. Technical Solution Overview
+
+### 1. IWMillVersions
+Create a centralized version management module that mirrors our IWMaterialsVersions in SBT:
+- Define same version constants for all libraries
+- Ensure compatibility with existing projects
+- Support for both Scala 2.13 and Scala 3
+
+### 2. IWMillDeps
+Create a dependency management module similar to IWMaterialsDeps:
+- Provide access to individual libraries with proper version control
+- Implement helper methods like useZIO(), useZIOAll(), etc.
+- Support for cross-platform (JVM/JS) dependencies
+
+### 3. IWScalaModule trait
+Create a standard module trait for Mill projects similar to IWScalaProjectPlugin:
+- Set Scala version defaults (prioritizing Scala 3)
+- Configure standard compiler options
+- Setup ScalafmtModule integration
+- Provide standard test configuration with UTest
+- Define publishing configuration for IW Maven repositories
+
+### 4. Publication Setup
+Document and implement standard configuration for publishing to IW Maven repositories:
+- Snapshot vs release handling
+- PomSettings standardization
+- Developer information
+
+### 5. Example Migration
+Create an example showing how to migrate from SBT to Mill:
+- Single project example
+- Multi-module project example
+- Project with JS/JVM cross-building
+
+## 5. Technical Considerations
+- Mill uses a different file format (build.sc vs build.sbt)
+- Different approach to module definitions and dependencies
+- Task definitions use different syntax and caching model
+- Need to ensure cross-version compatibility
+- Need to handle the ivy dependency notation differences
+
+## 6. Success Criteria
+- Can build existing projects with Mill using our standardized approach
+- Equivalent functionality to our SBT setup
+- Well-documented migration path
+- Performance improvements over SBT builds
+
+## 7. Approval
+
+PO Approval: _________________ Date: _________________
+
+Tech Lead Approval: _________________ Date: _________________
\ No newline at end of file
diff --git a/dev-logs/20250402-notes.md b/dev-logs/20250402-notes.md
new file mode 100644
index 0000000..17eda8a
--- /dev/null
+++ b/dev-logs/20250402-notes.md
@@ -0,0 +1,139 @@
+# Notes for Mill Support Implementation - 2025-04-02
+
+## Today's Accomplishments
+
+1. Completed research on Mill build tool structure and extension development
+2. Analyzed existing SBT infrastructure to understand equivalent implementation in Mill
+3. Created proof-of-concept implementation of key components:
+   - IWMillVersions - Centralized version management
+   - IWMillDeps - Standardized dependency management
+   - IWScalaModule - Standard module configuration
+   - IWPublishModule - Publishing configuration
+
+4. Created example project showing usage
+5. Documented approach and usage in README.md
+
+## Key Observations
+
+### Advantages of Mill
+
+1. More intuitive and readable build files
+   - Regular Scala code vs. SBT's DSL
+   - Method-based configuration vs. key-value pairs
+   - Cleaner module definition and inheritance
+
+2. Simpler extension development
+   - Regular library vs. complex plugin system
+   - Trait-based sharing of functionality
+   - Easier to understand and maintain
+
+3. Better performance
+   - Aggressive caching of build tasks
+   - More explicit task dependencies
+   - Faster incremental compilation
+
+4. Improved developer experience
+   - Better IDE support with type-checked build files
+   - More consistent error messages
+   - Easier to debug and troubleshoot
+
+### Implementation Notes
+
+1. **IWMillVersions**
+   - Direct port of IWMaterialsVersions
+   - Same version constants, same naming scheme
+   - Can be used directly by library users
+
+2. **IWMillDeps**
+   - Uses Mill's `ivy"org::name:version"` syntax
+   - Same helper methods as IWMaterialsDeps (useZIO, useZIOAll, etc.)
+   - Returns `Loose.Agg[Dep]` instead of SBT's `Seq[Def.Setting[_]]`
+
+3. **IWScalaModule**
+   - Extends Mill's ScalaModule and ScalafmtModule
+   - Sets default Scala version (3.6.3)
+   - Configures standard compiler options
+   - Enables SemanticDB for tooling
+   - Includes nested IWTests for standard test configuration
+
+4. **IWPublishModule**
+   - Configures publishing to IW Maven repositories
+   - Handles snapshots vs. releases based on version
+   - Uses environment variables for credentials
+
+## Issues to Address
+
+1. **Scala.js Support**
+   - Need to implement IWScalaJSModule for JS compilation
+   - Need to handle cross-platform dependencies properly
+   - Need to support timezone and locale configuration
+
+2. **Mill Plugin Ecosystem**
+   - Need to identify and integrate with essential Mill plugins
+   - Equivalent functionality to SBT plugins we currently use
+
+3. **Testing Framework**
+   - Currently using utest, but need to support ZIO Test
+   - Need to configure proper test initialization
+
+4. **Build Integration**
+   - Need to test with Nix and direnv
+   - Need to ensure compatibility with CI/CD pipelines
+
+## Next Development Steps
+
+### For Next Session (2025-04-03)
+
+1. **Create IWScalaJSModule**
+   - Support for Scala.js compilation
+   - Cross-platform dependency handling
+   - JS-specific configuration
+
+2. **Enhanced Test Support**
+   - Implement ZIO Test integration
+   - Configure proper test initialization
+   - Add test logging configurations
+
+3. **Multi-Module Example**
+   - Create example with multiple modules
+   - Show inter-module dependencies
+   - Demonstrate publishing configuration
+
+### For Future Sessions
+
+1. **Documentation**
+   - Create comprehensive migration guide
+   - Document all traits and components
+   - Provide examples for different use cases
+
+2. **Integration Testing**
+   - Test with real-world projects
+   - Measure performance vs. SBT
+   - Validate build equivalence
+
+3. **Release Planning**
+   - Define versioning strategy
+   - Setup CI/CD for the library
+   - Create announcement for the team
+
+## Migration Considerations
+
+1. **Incremental Approach**
+   - Start with new projects
+   - Test on non-critical projects first
+   - Gradually migrate existing projects
+
+2. **Dual Build Configuration**
+   - Initial phase: support both SBT and Mill
+   - Update IWMaterialsVersions and IWMillVersions together
+   - Maintain feature parity during transition
+
+3. **Knowledge Transfer**
+   - Create training materials
+   - Run workshops for the team
+   - Pair programming for initial migrations
+
+4. **Compatibility Monitoring**
+   - Keep track of SBT plugin updates
+   - Ensure Mill implementation stays up to date
+   - Regular testing of both build systems
\ No newline at end of file
diff --git a/dev-logs/20250402-plan.md b/dev-logs/20250402-plan.md
new file mode 100644
index 0000000..e30d341
--- /dev/null
+++ b/dev-logs/20250402-plan.md
@@ -0,0 +1,88 @@
+# Development Plan for 2025-04-02
+
+## Goals
+1. Create initial implementation plan for Mill build tool support
+2. Investigate Mill extension development approach
+3. Design the basic structure of IWMill components
+4. Begin researching key differences between SBT and Mill builds
+
+## Tasks
+
+### 1. Research Mill Build Structure (2 hours)
+- [x] Review Mill documentation for build definition approach
+- [x] Understand module concept in Mill vs. SBT
+- [x] Research dependency notation in Mill
+- [x] Investigate Mill extension development
+
+### 2. Analyze Existing SBT Components (1.5 hours)
+- [x] Review IWMaterialsVersions structure
+- [x] Review IWMaterialsDeps implementation
+- [x] Review IWScalaProjectPlugin settings
+- [x] Understand IW Maven repository configuration
+
+### 3. Design Mill Components Structure (2 hours)
+- [x] Design IWMillVersions object
+- [x] Design IWMillDeps object
+- [x] Design IWScalaModule trait
+- [x] Plan publishing configuration approach (IWPublishModule trait)
+
+### 4. Create Proof of Concept (2.5 hours)
+- [x] Set up a minimal Mill project structure
+- [x] Create basic file structure for Mill library
+- [x] Implement a simple version of IWMillVersions
+- [x] Create a test module that uses the library
+
+## Findings Summary
+
+### Mill vs SBT Differences
+1. Mill uses regular Scala code in `build.sc` files instead of SBT's DSL
+2. Mill modules are objects extending traits instead of SBT's project definitions
+3. Mill uses `ivy"org::name:version"` syntax instead of SBT's `"org" %% "name" % "version"`
+4. Mill features a more direct trait-based extension model versus SBT's plugin system
+5. Mill tasks are defined as methods with explicit dependencies
+
+### Mill Extension Development
+1. Mill extensions are regular JVM libraries that can be published to Maven
+2. Shared functionality is provided through traits that modules can extend
+3. No formal plugin system or activation - users explicitly mix in traits
+4. Creating extensions is simpler and requires less boilerplate
+
+### Implementation Approach
+1. Create a dedicated library (`mill-iw-support` or similar) with:
+   - IWMillVersions for centralized version management
+   - IWMillDeps for standardized dependency definitions
+   - IWScalaModule trait for standard module configuration
+   - IWPublishModule trait for publishing configuration
+2. Publish to IW Maven repositories
+3. Users add the library as a dependency in their `build.sc` files
+
+## Implementation Progress
+1. Created project structure for `mill-iw-support` library
+2. Implemented IWMillVersions object with all library versions
+3. Implemented IWMillDeps object with core dependency definitions
+4. Created IWScalaModule trait with standard compiler options
+5. Created IWPublishModule trait for IW Maven repositories
+6. Created a working example project structure
+7. Documented usage in README.md
+
+## Success Criteria
+- Completed research on Mill build structure and extension development ✅
+- Analyzed existing SBT components for equivalent Mill implementation ✅
+- Designed structure for Mill component equivalents ✅
+- Created detailed implementation plan for Mill support library ✅
+- Created initial proof of concept for validation ✅
+
+## Next Steps
+1. Expand the proof of concept with more components
+2. Test building and publishing the library
+3. Create a more comprehensive example with multiple modules
+4. Test integration with real-world projects
+5. Begin writing migration guides and documentation
+
+## Notes and Considerations
+- Mill's trait-based approach is a better fit for creating composable, reusable components
+- Unlike SBT plugins, Mill extensions are just regular libraries, simplifying development
+- Mill's syntax and structure are more intuitive and approachable than SBT
+- Cross-building in Mill uses a different approach with `Cross[Module]` that needs careful consideration
+- Need to ensure our Mill solution has feature parity with our SBT solution
+- For next development session, focus on adding cross-platform (JVM/JS) support
\ No newline at end of file
diff --git a/dev-logs/20250402-research.md b/dev-logs/20250402-research.md
new file mode 100644
index 0000000..974a1b6
--- /dev/null
+++ b/dev-logs/20250402-research.md
@@ -0,0 +1,185 @@
+# Research on Mill vs SBT - 2025-04-02
+
+## Key Components of Current SBT Infrastructure
+
+### 1. IWMaterialsVersions
+- Simple object with val declarations for all library versions
+- Centralized version management through a single file
+- Versioning for all major libraries (ZIO, Akka, HTTP clients, etc.)
+- Used as a reference in IWMaterialsDeps
+
+### 2. IWMaterialsDeps
+- Contains dependency definitions with proper cross-platform support
+- Groups related dependencies with helper methods like `useZIO()`, `useZIOAll()`
+- Handles Scala.js dependencies with `%%%` cross-version support
+- Implements specialized library sets (ZIO, Akka, HTTP, etc.)
+- Provides standard compiler options for certain libraries (like ZIO JSON)
+
+### 3. IWScalaProjectPlugin
+- Implements an SBT AutoPlugin for standardizing projects
+- Sets default Scala version (currently prioritizing Scala 3.6.3)
+- Enables SemanticDB for tooling
+- Sets up scalafmt and scalafix integration
+- Configures publishing to IW Maven repositories
+- Sets test logging preferences
+
+### 4. IWPluginPresets
+- Centralizes SBT plugin management
+- Provides helper methods for adding common plugin sets
+- Handles complex plugin dependencies (like Scala.js ecosystem)
+
+### 5. VitePlugin
+- Example of custom SBT plugin for JavaScript tooling
+- Shows integration with external tools like Vite
+- Manages dev server lifecycle
+- Configures environment variables and file monitoring
+
+## Mill Build Tool Overview
+
+Based on our research from the Mill documentation, here are the key aspects of Mill:
+
+### 1. Core Features
+- Supports multiple languages (Java, Scala, Kotlin)
+- Faster builds through aggressive caching and parallelism
+- Better IDE support with superior autocomplete and navigation
+- Requires fewer plugins for common workflows
+- Build files are regular Scala code (build.sc)
+
+### 2. Module System
+- Uses a module tree and task graph with immutable configuration
+- Modules are defined as objects extending traits (like `ScalaModule`)
+- Example:
+```scala
+object foo extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::scalatags:0.13.1"
+  )
+}
+```
+- Tasks are defined as methods that can reference other tasks
+- Automatic caching and incremental computation
+
+### 3. Dependency Management
+- Uses Ivy syntax: `ivy"org::name:version"` (with :: for Scala deps)
+- Dependencies defined in module definition:
+  - `def ivyDeps = Agg(...)` for external dependencies
+  - `def moduleDeps = Seq(...)` for internal module dependencies
+- Can define custom resolvers and credentials
+
+### 4. Publishing
+- Uses `PublishModule` trait
+- Requires `def publishVersion` and `def pomSettings`
+- Example:
+```scala
+object foo extends ScalaModule with PublishModule {
+  def publishVersion = "0.0.1"
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT)
+  )
+}
+```
+
+### 5. Extension Development
+- Mill uses traits for sharing functionality between modules
+- Can create custom modules that extend existing Mill modules
+- Extensions are regular JVM libraries that can be published to Maven repos
+- Isolated classloaders for worker modules to avoid conflicts
+
+## Differences Between SBT and Mill
+
+### 1. Configuration Syntax
+- SBT: DSL in build.sbt files with key-value pairs
+- Mill: Regular Scala code in build.sc files, with modules as objects
+
+### 2. Plugin System
+- SBT: Formal plugin system with AutoPlugin
+- Mill: Traits and regular libraries, no formal plugin system
+
+### 3. Dependency Notation
+- SBT: `"org" %% "name" % "version"`
+- Mill: `ivy"org::name:version"`
+
+### 4. Cross Building
+- SBT: Uses `+` prefix for commands, crossScalaVersions setting
+- Mill: Uses `Cross[Module]` for multi-version builds, with version-specific source dirs
+
+### 5. Task Definition
+- SBT: Tasks defined as settings with complex DSL
+- Mill: Tasks defined as methods with explicit dependencies
+
+## Mill Equivalent Components Design
+
+### 1. IWMillVersions
+- Object with the same version constants as IWMaterialsVersions
+- Example:
+```scala
+object IWMillVersions {
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  // ... other versions
+}
+```
+
+### 2. IWMillDeps
+- Object with methods to create dependencies with proper Mill notation
+- Example:
+```scala
+object IWMillDeps {
+  def zio = ivy"dev.zio::zio:${IWMillVersions.zio}"
+  def zioConfig = ivy"dev.zio::zio-config:${IWMillVersions.zioConfig}"
+  
+  def useZIO() = Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+}
+```
+
+### 3. IWScalaModule trait
+- Trait that can be mixed into ScalaModule
+- Sets default Scala version and compiler options
+- Example:
+```scala
+trait IWScalaModule extends ScalaModule {
+  def scalaVersion = "3.6.3"
+  
+  // Standard compiler options
+  def scalacOptions = super.scalacOptions() ++ Seq(
+    "-Xfatal-warnings",
+    "-deprecation"
+  )
+}
+```
+
+### 4. IWPublishModule trait
+- Extension of PublishModule for IW Maven repository setup
+- Example:
+```scala
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  def repositoryURL = if (publishVersion().endsWith("-SNAPSHOT"))
+    "https://dig.iterative.works/maven/snapshots"
+  else
+    "https://dig.iterative.works/maven/releases"
+}
+```
+
+## Implementation Planning
+
+For each component we'll need to:
+
+1. Create the basic structure of the Mill support library
+2. Implement the version and dependency objects
+3. Create traits for standard module configuration
+4. Implement publishing support
+5. Create example modules and migration guides
+
+Mill's trait-based approach should make our implementation more natural and flexible than SBT plugins, as we can create composable traits that work directly with Mill's module system.
\ No newline at end of file
diff --git a/dev-logs/TODO.md b/dev-logs/TODO.md
new file mode 100644
index 0000000..858bf51
--- /dev/null
+++ b/dev-logs/TODO.md
@@ -0,0 +1,99 @@
+# TODO: Mill Build Tool Support
+
+## Change Request Reference
+- [Mill Build Tool Support](/change-requests/202501-mill.md)
+
+## Completed Tasks
+### 1. Research and Planning
+- [x] Review all existing SBT plugins and configurations in detail
+- [x] Study Mill documentation and examples
+- [x] Identify key differences in build definition approach
+- [x] Design the structure of the Mill support library
+- [x] Document Mill extension development approach
+
+### 2. Project Setup
+- [x] Create project structure for mill-iw-support library
+- [x] Set up build configuration for Mill library
+- [x] Configure cross-version compilation (Scala 2.13 and 3.x)
+- [x] Set up publishing to IW Maven repositories
+
+### 3. IWMillVersions Implementation
+- [x] Create IWMillVersions object with same versions as IWMaterialsVersions
+- [x] Ensure consistent version naming scheme
+- [x] Add comprehensive version entries for all libraries
+- [x] Add comments for version compatibility notes
+
+### 4. IWMillDeps Implementation
+- [x] Create IWMillDeps object with equivalent library definitions
+- [x] Implement helper methods (useZIO, useZIOAll, etc.)
+- [x] Implement all library categories (ZIO, Akka, HTTP, etc.)
+- [x] Add documentation comments for all dependencies
+
+### 5. IWScalaModule Implementation
+- [x] Create base IWScalaModule trait
+- [x] Configure default compiler options matching SBT configuration
+- [x] Setup ScalafmtModule integration
+- [x] Configure SemanticDB for tooling support
+- [x] Create standard IWTestModule for testing with UTest
+- [x] Create IWPublishModule for IW Maven repositories
+- [x] Configure snapshot vs release repository handling
+
+### 6. Documentation and Examples
+- [x] Create comprehensive README.md for the library
+- [x] Create example project with basic single module
+
+## Remaining Tasks
+
+### 1. Cross-Platform Support
+- [ ] Implement IWScalaJSModule for JS compilation
+- [ ] Configure JS dependencies and tooling support
+- [ ] Setup cross-platform dependency handling (JVM/JS)
+- [ ] Add Scala.js-specific configurations
+- [ ] Implement locale and timezone support equivalent to SBT
+
+### 2. Enhanced Testing Support
+- [ ] Create standard IWTestModule for testing with ZIO Test
+- [ ] Configure proper test initialization
+- [ ] Add test logging configurations
+- [ ] Add support for early-semver versioning
+
+### 3. Testing and Validation
+- [ ] Create multi-module project test case
+- [ ] Create cross-platform (JVM/JS) project test case
+- [ ] Implement standard example app with identical SBT and Mill builds
+- [ ] Measure and document performance differences
+- [ ] Validate dependency resolution works correctly
+- [ ] Test compatibility with different Scala versions
+
+### 4. Additional Documentation and Examples
+- [ ] Document all available modules and traits in detail
+- [ ] Create migration guide from SBT to Mill
+- [ ] Create example projects with common configurations:
+  - [ ] Multi-module project 
+  - [ ] Cross-platform JVM/JS project
+  - [ ] ZIO project
+  - [ ] Project with JS/Vite integration
+- [ ] Update Obsidian documentation with Mill build practices
+
+### 5. Publication and Release
+- [ ] Finalize versioning of the Mill support library
+- [ ] Document release process
+- [ ] Update IW Maven publication scripts
+- [ ] Create first release
+- [ ] Test with real-world projects
+- [ ] Create announcement and presentation for the team
+
+## Priority Order
+1. Cross-platform support (JS/JVM)
+2. Enhanced testing support with ZIO Test
+3. Multi-module examples and testing
+4. Comprehensive documentation
+5. Publication and release
+
+## Timeline Markers
+- Research completion: April 2, 2025 ✅
+- Project setup and core components: April 2, 2025 ✅
+- Cross-platform support: April 10, 2025
+- Testing and validation: April 26, 2025
+- Documentation: May 3, 2025
+- Release: May 10, 2025
\ No newline at end of file
diff --git a/mill-iw-support/README.md b/mill-iw-support/README.md
new file mode 100644
index 0000000..4986e5c
--- /dev/null
+++ b/mill-iw-support/README.md
@@ -0,0 +1,109 @@
+# Mill IW Support
+
+This library provides support for using Mill build tool with Iterative Works standards and best practices. It's equivalent to our SBT infrastructure (sbt-iw-projects and sbt-iw-plugin-presets) but for Mill.
+
+## Key Components
+
+### IWMillVersions
+
+Centralized version management for all libraries:
+
+```scala
+import works.iterative.mill.IWMillVersions
+
+// Access specific versions
+val zioVersion = IWMillVersions.zio // "2.1.16"
+```
+
+### IWMillDeps
+
+Standardized dependency management with proper versioning:
+
+```scala
+import works.iterative.mill.IWMillDeps
+
+// Use individual dependencies
+IWMillDeps.zio          // ivy"dev.zio::zio:2.1.16"
+IWMillDeps.zioJson      // ivy"dev.zio::zio-json:0.7.36"
+IWMillDeps.tapirCore    // ivy"com.softwaremill.sttp.tapir::tapir-core:1.11.16"
+
+// Use dependency groups
+IWMillDeps.useZIO()     // Core ZIO dependencies with test framework
+IWMillDeps.useZIOAll()  // Comprehensive ZIO stack
+```
+
+### IWScalaModule
+
+Standard module configuration for Scala projects:
+
+```scala
+import mill._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule {
+  // Use default Scala version (3.6.3)
+  // and standard compiler options with SemanticDB enabled
+  
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO()
+  
+  // Standard test module configuration
+  object test extends Tests with IWTests
+}
+```
+
+### IWPublishModule
+
+Standard publishing configuration for IW Maven repositories:
+
+```scala
+import mill._
+import mill.scalalib.publish._
+import works.iterative.mill._
+
+object myProject extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "My Project",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/my-project",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "my-project"),
+    developers = Seq(
+      Developer("dev", "Developer Name", "https://github.com/dev")
+    )
+  )
+  
+  // publishTo is automatically configured based on version
+  // (snapshots vs releases)
+}
+```
+
+## Getting Started
+
+Add the library to your `build.sc` file:
+
+```scala
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+```
+
+Then extend the appropriate traits in your module definitions:
+
+```scala
+object root extends IWScalaModule with IWPublishModule {
+  // ... configuration ...
+}
+```
+
+## Examples
+
+See the `example` directory for a complete working example.
+
+## Benefits of Using Mill
+
+- Faster builds through aggressive caching
+- Better IDE support with type-checked build files
+- Cleaner syntax and easier configuration
+- More intuitive dependency management
+- Easier extension with custom tasks
\ No newline at end of file
diff --git a/mill-iw-support/build.sc b/mill-iw-support/build.sc
new file mode 100644
index 0000000..5df80ae
--- /dev/null
+++ b/mill-iw-support/build.sc
@@ -0,0 +1,32 @@
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+import mill.scalalib.scalafmt._
+
+object `mill-iw-support` extends Cross[IWMillSupportModule]("2.13.16", "3.6.3")
+
+class IWMillSupportModule(val crossScalaVersion: String) extends CrossScalaModule with ScalafmtModule with PublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+
+  def pomSettings = PomSettings(
+    description = "Iterative Works Mill Support Library",
+    organization = "works.iterative",
+    url = "https://github.com/iterative-works/mill-iw-support",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("iterative-works", "mill-iw-support"),
+    developers = Seq(
+      Developer("mph", "Michal Přihoda", "https://github.com/iterative-works")
+    )
+  )
+
+  def ivyDeps = Agg(
+    ivy"com.lihaoyi::os-lib:0.9.3"
+  )
+
+  object test extends Tests with ScalafmtModule {
+    def ivyDeps = Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+    def testFramework = "utest.runner.Framework"
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/build.sc b/mill-iw-support/example/build.sc
new file mode 100644
index 0000000..5da77ab
--- /dev/null
+++ b/mill-iw-support/example/build.sc
@@ -0,0 +1,30 @@
+import mill._
+import mill.scalalib._
+import $ivy.`works.iterative::mill-iw-support:0.1.0-SNAPSHOT`
+import works.iterative.mill._
+
+object example extends IWScalaModule with IWPublishModule {
+  def publishVersion = "0.1.0-SNAPSHOT"
+  
+  def pomSettings = PomSettings(
+    description = "Example Mill Project using IW Mill Support",
+    organization = "com.example",
+    url = "https://github.com/example/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("example", "example"),
+    developers = Seq(
+      Developer("developer", "Example Developer", "https://github.com/example")
+    )
+  )
+  
+  // Use centralized dependency versions and definitions
+  def ivyDeps = super.ivyDeps() ++ IWMillDeps.useZIO() ++ Agg(
+    IWMillDeps.zioJson,
+    IWMillDeps.tapirCore,
+    IWMillDeps.tapirZIO,
+    IWMillDeps.tapirZIOJson
+  )
+  
+  // Define test module extending IWTests
+  object test extends Tests with IWTests
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/src/Example.scala b/mill-iw-support/example/src/Example.scala
new file mode 100644
index 0000000..aa28980
--- /dev/null
+++ b/mill-iw-support/example/src/Example.scala
@@ -0,0 +1,27 @@
+package example
+
+import zio._
+import zio.json._
+
+// Simple example class
+case class User(id: String, name: String, email: String)
+
+object User {
+  // JSON codecs using ZIO JSON
+  implicit val encoder: JsonEncoder[User] = DeriveJsonEncoder.gen[User]
+  implicit val decoder: JsonDecoder[User] = DeriveJsonDecoder.gen[User]
+}
+
+object Example extends ZIOAppDefault {
+  
+  val program = for {
+    _ <- Console.printLine("Starting example application")
+    user = User("1", "John Doe", "john@example.com")
+    json <- ZIO.succeed(user.toJson)
+    _ <- Console.printLine(s"User as JSON: $json")
+    parsed <- ZIO.fromEither(json.fromJson[User])
+    _ <- Console.printLine(s"Parsed user: $parsed")
+  } yield ()
+  
+  def run = program
+}
\ No newline at end of file
diff --git a/mill-iw-support/example/test/src/ExampleTest.scala b/mill-iw-support/example/test/src/ExampleTest.scala
new file mode 100644
index 0000000..20f0c06
--- /dev/null
+++ b/mill-iw-support/example/test/src/ExampleTest.scala
@@ -0,0 +1,27 @@
+package example
+
+import utest._
+import zio._
+import zio.json._
+import zio.test._
+import zio.test.Assertion._
+
+object ExampleTest extends TestSuite {
+  val tests = Tests {
+    test("User JSON serialization") {
+      val user = User("1", "John Doe", "john@example.com")
+      val json = user.toJson
+      val expected = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      
+      assert(json == expected)
+    }
+    
+    test("User JSON deserialization") {
+      val json = """{"id":"1","name":"John Doe","email":"john@example.com"}"""
+      val parsed = json.fromJson[User]
+      val expected = User("1", "John Doe", "john@example.com")
+      
+      assert(parsed == Right(expected))
+    }
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala
new file mode 100644
index 0000000..e21af78
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillDeps.scala
@@ -0,0 +1,78 @@
+package works.iterative.mill
+
+import mill.api.Loose
+import mill.scalalib.Dep
+
+/**
+ * Standardized dependency management for Iterative Works projects using Mill.
+ * This object provides methods to get dependencies with proper versioning.
+ * 
+ * All versions are centralized in [[IWMillVersions]].
+ */
+object IWMillDeps {
+  import IWMillVersions as V
+
+  // ZIO Core
+  def zio = ivy"dev.zio::zio:${V.zio}"
+  def zioTest = ivy"dev.zio::zio-test:${V.zio}"
+  def zioTestSbt = ivy"dev.zio::zio-test-sbt:${V.zio}"
+  def zioStreams = ivy"dev.zio::zio-streams:${V.zio}"
+
+  // ZIO Extensions
+  def zioConfig = ivy"dev.zio::zio-config:${V.zioConfig}"
+  def zioConfigTypesafe = ivy"dev.zio::zio-config-typesafe:${V.zioConfig}"
+  def zioConfigMagnolia = ivy"dev.zio::zio-config-magnolia:${V.zioConfig}"
+  def zioJson = ivy"dev.zio::zio-json:${V.zioJson}"
+  def zioLogging = ivy"dev.zio::zio-logging:${V.zioLogging}"
+  def zioLoggingSlf4j = ivy"dev.zio::zio-logging-slf4j:${V.zioLogging}"
+  def zioPrelude = ivy"dev.zio::zio-prelude:${V.zioPrelude}"
+  def zioInteropCats = ivy"dev.zio::zio-interop-cats:${V.zioInteropCats}"
+  def zioInteropReactiveStreams = ivy"dev.zio::zio-interop-reactivestreams:${V.zioInteropReactiveStreams}"
+  def zioNIO = ivy"dev.zio::zio-nio:${V.zioNIO}"
+  def zioCli = ivy"dev.zio::zio-cli:${V.zioCli}"
+  def zioSchema = ivy"dev.zio::zio-schema:${V.zioSchema}"
+  def zioSchemaDerivation = ivy"dev.zio::zio-schema-derivation:${V.zioSchema}"
+
+  // Helper methods for ZIO
+  def useZIO(): Loose.Agg[Dep] = Loose.Agg(
+    zio,
+    zioTest,
+    zioTestSbt
+  )
+
+  def useZIOJson: Loose.Agg[Dep] = Loose.Agg(
+    zioJson
+  )
+
+  def useZIOAll(): Loose.Agg[Dep] = useZIO() ++ Loose.Agg(
+    zioStreams,
+    zioConfig,
+    zioConfigTypesafe,
+    zioConfigMagnolia,
+    zioLogging,
+    zioPrelude
+  ) ++ useZIOJson
+
+  // Database
+  def quill = ivy"io.getquill::quill-jdbc-zio:${V.quill}"
+  def magnum = ivy"com.augustnagro::magnum_3:${V.magnum}"
+  def magnumZIO = ivy"com.augustnagro::magnumzio_3:${V.magnum}"
+  def magnumPG = ivy"com.augustnagro::magnumpg_3:${V.magnum}"
+
+  // HTTP
+  def tapirCore = ivy"com.softwaremill.sttp.tapir::tapir-core:${V.tapir}"
+  def tapirZIO = ivy"com.softwaremill.sttp.tapir::tapir-zio:${V.tapir}"
+  def tapirZIOJson = ivy"com.softwaremill.sttp.tapir::tapir-json-zio:${V.tapir}"
+  
+  // UI/Frontend
+  def scalatags = ivy"com.lihaoyi::scalatags:${V.scalatags}"
+  def laminar = ivy"com.raquo::laminar:${V.laminar}"
+  def waypoint = ivy"com.raquo::waypoint:${V.waypoint}"
+  def urlDsl = ivy"be.doeraene::url-dsl:${V.urlDsl}"
+  
+  // Testing
+  def scalaTest = ivy"org.scalatest::scalatest:${V.scalaTest}"
+  
+  // Logging
+  def logbackClassic = ivy"ch.qos.logback:logback-classic:${V.logbackClassic}"
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala
new file mode 100644
index 0000000..4e3150a
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWMillVersions.scala
@@ -0,0 +1,55 @@
+package works.iterative.mill
+
+/**
+ * Centralized version management for Iterative Works projects using Mill.
+ * This object contains all library versions used across projects.
+ * 
+ * Update this object to bump versions for all projects.
+ */
+object IWMillVersions {
+  // ZIO Ecosystem
+  val zio = "2.1.16"
+  val zioConfig = "4.0.3"
+  val zioCli = "0.7.0"
+  val zioInteropCats = "23.1.0.3"
+  val zioInteropReactiveStreams = "2.0.2"
+  val zioJson = "0.7.36"
+  val zioLogging = "2.5.0"
+  val zioNIO = "2.0.2"
+  val zioPrelude = "1.0.0-RC39"
+  val zioQuery = "0.7.6"
+  val zioSchema = "1.6.3"
+
+  // Akka Ecosystem
+  val akka = "2.6.18"
+  val akkaHttp = "10.4.0"
+
+  // Other Libraries
+  val cats = "2.13.0"
+  val caliban = "2.9.2"
+  val chimney = "1.7.3"
+  val ducktape = "0.2.7"
+  val elastic4s = "7.12.4"
+  val http4s = "0.23.30"
+  val http4sBlaze = "0.23.17"
+  val http4sPac4J = "5.0.0"
+  val laminar = "17.2.0"
+  val laminext = "0.17.0"
+  val logbackClassic = "1.5.17"
+  val magnum = "2.0.0-M1"
+  val pac4j = "6.0.3"
+  val play = "2.8.18"
+  val playJson = "2.9.3"
+  val quill = "4.8.6"
+  val scalaJsMacroTaskExecutor = "1.1.1"
+  val scalaJsJavaSecureRandom = "1.0.0"
+  val scalatags = "0.13.1"
+  val scalaTest = "3.2.19"
+  val slick = "3.3.3"
+  val sttpClient3 = "3.10.3"
+  val sttpClient4 = "4.0.0-RC1"
+  val support = "1.7.0"
+  val tapir = "1.11.16"
+  val urlDsl = "0.7.0"
+  val waypoint = "9.0.0"
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWPublishModule.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWPublishModule.scala
new file mode 100644
index 0000000..29a2df4
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWPublishModule.scala
@@ -0,0 +1,43 @@
+package works.iterative.mill
+
+import mill._
+import mill.scalalib._
+import mill.scalalib.publish._
+
+/**
+ * Standard publish module trait for Iterative Works projects using Mill.
+ * This trait sets up standard publishing configuration for IW Maven repositories.
+ */
+trait IWPublishModule extends PublishModule {
+  def publishVersion: T[String]
+  
+  def pomSettings: T[PomSettings]
+  
+  /**
+   * Determines the repository URL based on version.
+   * - Snapshot versions go to the snapshots repository
+   * - Release versions go to the releases repository
+   */
+  def repositoryUrl: T[String] = T {
+    if (publishVersion().endsWith("-SNAPSHOT"))
+      "https://dig.iterative.works/maven/snapshots"
+    else
+      "https://dig.iterative.works/maven/releases"
+  }
+  
+  /**
+   * Configure publish credentials from environment variables.
+   */
+  def publishCredentials: T[PublishCredentials] = T {
+    val username = sys.env.getOrElse("IW_USERNAME", "")
+    val password = sys.env.getOrElse("IW_PASSWORD", "")
+    PublishCredentials("GitBucket Maven Repository", "dig.iterative.works", username, password)
+  }
+  
+  /**
+   * Configure publication to IW Maven repository.
+   */
+  def publishTo: T[Option[PublishRepository]] = T {
+    Some(PublishRepository(repositoryUrl(), publishCredentials()))
+  }
+}
\ No newline at end of file
diff --git a/mill-iw-support/src/main/scala/works/iterative/mill/IWScalaModule.scala b/mill-iw-support/src/main/scala/works/iterative/mill/IWScalaModule.scala
new file mode 100644
index 0000000..4f7c38c
--- /dev/null
+++ b/mill-iw-support/src/main/scala/works/iterative/mill/IWScalaModule.scala
@@ -0,0 +1,54 @@
+package works.iterative.mill
+
+import mill._
+import mill.scalalib._
+import mill.scalalib.scalafmt._
+
+/**
+ * Standard Scala module trait for Iterative Works projects using Mill.
+ * This trait sets up standard compiler options and configuration.
+ */
+trait IWScalaModule extends ScalaModule with ScalafmtModule {
+  // Default to Scala 3.6.3 as in SBT
+  def scalaVersion = "3.6.3"
+  
+  // Default compiler options
+  def scalacOptions = super.scalacOptions() ++ (
+    if (scalaVersion().startsWith("2.")) {
+      Seq(
+        "-Xfatal-warnings",
+        "-deprecation",
+        "-feature",
+        "-unchecked",
+        "-language:higherKinds",
+        "-language:implicitConversions",
+        "-Wunused:imports"
+      )
+    } else {
+      Seq(
+        "-Xfatal-warnings",
+        "-deprecation",
+        "-feature",
+        "-unchecked",
+        "-language:higherKinds",
+        "-language:implicitConversions",
+        "-Wunused:imports"
+      )
+    }
+  )
+  
+  // Enable SemanticDB for tooling
+  def semanticDbOptions = Seq(
+    "-Xsemanticdb"
+  )
+  
+  // Override scalacOptions to include SemanticDB options
+  override def scalacOptions = super.scalacOptions() ++ semanticDbOptions
+  
+  // Test configuration
+  trait IWTests extends ScalaTests with TestModule.Utest with ScalafmtModule {
+    def ivyDeps = super.ivyDeps() ++ Agg(
+      ivy"com.lihaoyi::utest:0.8.2"
+    )
+  }
+}
\ No newline at end of file