❓ Frequently Asked Questions

Mica is currently a prototype under active development (Phase 3). While the compiler works and can generate native binaries, the language is still iterating on core semantics and tooling.

You should expect:

• Breaking changes between releases
• Incomplete standard library
• Evolving best practices
• Active experimentation with language features

Mica is perfect for learning compiler design, experimenting with effect systems, or prototyping language ideas—but not yet recommended for production systems.

Mica is designed to be learned in an afternoon:

• Syntax: 2-3 hours (10 core constructs)
• Effect system: 1-2 hours (capabilities and using blocks)
• Concurrency: 1 hour (spawn/await patterns)
• Complete tour: 4-6 hours

The Language Tour covers everything with runnable examples. The Examples Gallery provides 20+ programs to study.

Minimum requirements:

• Rust 1.70+ (install via rustup)
• 4 GB RAM (for compilation)
• macOS, Linux, or Windows with WSL2
• ~500 MB disk space

LLVM is bundled with Rust, so no additional dependencies are needed.

While both are systems languages with memory safety, key differences include:

• Explicit effects: Mica tracks all side effects at the type level with capabilities
• Deterministic concurrency: Built-in spawn/await with reproducible execution
• Simplicity: 10 core constructs vs Rust's extensive syntax
• Learning curve: Weekend to learn vs months for Rust
• Inspectable compiler: Every stage exposed via CLI

Mica prioritizes explicitness and auditability over maximum performance optimization.

No. Mica uses move semantics and RAII (Resource Acquisition Is Initialization) for memory management:

• Values are moved by default
• using blocks provide automatic cleanup
• No garbage collection pauses
• Predictable performance

A Rust-style borrow checker is planned for Phase 4 to prevent use-after-move errors at compile time.

Explicit effects make programs auditable and testable:

• Security: Know exactly what resources a function can access
• Testing: Mock capabilities with deterministic shims
• Reasoning: Function signatures tell the full story
• Composition: Effects propagate automatically through call chains

Example: func process(io: IO) !{io} declares that this function performs IO operations.

Mica's concurrency model guarantees reproducible results:

• Structured tasks: spawn/await with clear lifetimes
• No data races: Effect system prevents shared mutable state
• Deterministic scheduling: Same inputs = same outputs
• Testability: Concurrent code can be unit tested reliably

This makes debugging and testing concurrent programs much easier than traditional threading models.

A dedicated Language Server Protocol (LSP) implementation is planned for Phase 4. Currently available:

• CLI tools: Inspect every compiler stage
• Pretty-printer: Format code consistently
• JSON output: Machine-readable diagnostics
• cargo watch: Auto-run on file changes

See the Tooling Roadmap for LSP plans.

Debugging strategies:

• Compiler stages: Use --ast, --ir, --llvm to inspect transformations
• Capability logging: Trace IO/network operations through capability providers
• Deterministic execution: Bugs reproduce reliably
• Testing shims: Mock capabilities for isolated testing
• Rich diagnostics: Compiler provides detailed error messages

Future: Time-travel debugging with deterministic replay is planned.

Yes! Interop options:

• C ABI: Export functions with C-compatible signatures
• Python bridges: Planned via FFI (Phase 5)
• JavaScript: WASM target planned
• Rust: Compatible memory model

See the Ecosystem Roadmap for interop plans.

Mica compiles to native code via LLVM with zero-cost abstractions:

• AOT compilation: No JIT overhead
• LLVM optimization: Industry-standard optimizations
• No GC: Predictable latency
• Effect analysis: Enables parallelization

Target: Within 10% of equivalent Rust for most workloads. Benchmarks coming in Phase 4.

Mica prioritizes fast compile times:

• Small examples: <1 second
• Medium projects: 5-10 seconds
• Incremental builds: Very fast (caching planned)

Much faster than Rust due to simpler type system and smaller surface area.

Contributions are welcome! Ways to help:

• Code: Fix bugs, implement features (check issues)
• Documentation: Improve guides, add examples
• Testing: Write test cases, find bugs
• Design: Propose language features via RFCs
• Tutorials: Create learning materials

See the Contributing Guide for details.

Get help through:

• GitHub Issues: Bug reports and questions
• Discussions: Coming soon on GitHub
• Documentation: Comprehensive guides here

Mica does not yet declare a license. Until one is added, please reach out to the maintainers before using Mica in production settings.

A permissive open-source license is planned before the Phase 5 ecosystem launch.

There's no fixed timeline, but the roadmap outlines:

• Phase 3 (Current): Backend & runtime
• Phase 4: Tooling & IDE support
• Phase 5: Ecosystem & standard library
• Phase 6: Community growth

1.0 will likely come after Phase 5, when the language is stable and production-tested.

Yes! Planned for Phase 5:

• mica.toml manifest format
• mica package CLI commands
• Hosted registry with signed packages
• Capability declarations in manifests
• Reproducible builds

See the Ecosystem Roadmap for details.

Current: macOS, Linux, Windows (via WSL2)

Planned:

• Native Windows support
• WebAssembly target
• Embedded systems (ARM)
• Mobile (iOS, Android via cross-compilation)

LLVM backend provides excellent platform support out of the box.