Eclexia: Economics-as-Code

A programming language where economics is a first-class paradigm Making resource-efficient, carbon-aware software the default, not the exception.

🌟 What is Eclexia?

Eclexia introduces Economics-as-Code: a revolutionary programming paradigm where economic principles—scarcity, trade-offs, and optimization—are built into the language itself. Instead of treating performance and resource usage as afterthoughts, Eclexia makes them first-class concerns with:

Resource types with dimensional analysis (energy, time, memory, carbon)

Adaptive blocks that automatically select optimal algorithms based on runtime constraints

Shadow prices that guide decision-making using economic principles

Carbon-aware execution to minimize environmental impact

Multi-objective optimization declared directly in code

The Problem

Traditional programming forces developers to:

Manually optimize for performance, energy, or cost Hard-code algorithm choices that don’t adapt to changing conditions Ignore carbon footprint and sustainability Trade off between competing objectives with no principled framework

The Solution

Eclexia makes these decisions automatic and economically optimal:

adaptive def matrix_multiply(A: Matrix, B: Matrix) → Matrix @requires: energy < 100J, latency < 500ms @optimize: minimize energy, minimize carbon { @solution "gpu_accelerated": @when: gpu_available && matrix_size > 1000 @provides: energy: 50J, latency: 100ms, carbon: 5gCO2e { gpu::multiply(A, B) }

@solution "parallel_cpu":
    @when: cpu_cores >= 4
    @provides: energy: 80J, latency: 300ms, carbon: 8gCO2e
{
    parallel::multiply(A, B)
}

    @solution "naive":
        @when: true  // always available
        @provides: energy: 30J, latency: 800ms, carbon: 3gCO2e
    {
        naive::multiply(A, B)
    }
}

The runtime automatically selects the best solution based on:

Available resources (energy budget, CPU cores, GPU availability) Current carbon intensity of the power grid Shadow prices that reflect the true cost of resources Your declared optimization objectives

📚 Documentation

Core Documents

Document Description Audience

White Paper Comprehensive introduction to Economics-as-Code All readers

Formal Proofs Mathematical foundations and correctness proofs Researchers, PL theorists

IP Claims Intellectual property analysis and strategy Legal, business

Language Specification Complete language syntax and semantics Language implementers

Tutorial Getting started guide with examples Developers

API Reference Standard library documentation Developers

Quick Navigation

👋 New to Eclexia? Start with the White Paper (Section 1-3) or Tutorial 🔬 Want the theory? Read the Formal Proofs and Language Specification 💼 Business/Legal interests? See IP Claims for patent strategy and commercialization 👨‍💻 Ready to code? Check out Examples and Getting Started

🚀 Quick Start

Installation

From this repository:

# Build from source (requires Rust 1.75+)
cargo build --release

# Verify the build works
cargo test
cargo run -- run examples/hello.ecl

The compiler binary will be at target/release/eclexia.

Hello World with Resources

def main() → Unit @requires: energy < 1J { println("Hello, Economics-as-Code!") }

Your First Adaptive Function

adaptive def fibonacci(n: Int) → Int @requires: energy < 100J @optimize: minimize latency { @solution "memoized": @when: n > 20 @provides: energy: 50J, latency: 5ms { memo_fib(n) }

    @solution "naive":
        @provides: energy: 10J, latency: 100ms
    {
        if n <= 1 then n
        else fibonacci(n-1) + fibonacci(n-2)
    }
}

Run it:

cargo run -- run examples/fibonacci.ecl

💡 Key Features

1. Resource Types with Dimensions

Prevent bugs at compile time:

let energy: Energy = 100J let time: Time = 5s let power: Power = energy / time // ✓ Correctly typed as Watts

1. Adaptive Execution

The runtime automatically chooses the best algorithm:

adaptive def sort(arr: Array[Int]) → Array[Int] @requires: energy < 50J, latency < 100ms @optimize: minimize energy { @solution "quicksort": @when: length(arr) > 100 @provides: energy: 40J, latency: 50ms { /* …​ */ }

    @solution "insertion_sort":
        @when: length(arr) <= 100
        @provides: energy: 10J, latency: 80ms
    { /* ... */ }
}

1. Shadow Prices

The runtime computes shadow prices—the marginal value of each resource—to guide decisions:

def analyze() → Unit @observe: shadow_prices { // Runtime automatically computes: // - λ_energy: how valuable is 1 more Joule? // - λ_time: how valuable is 1 more millisecond? // - λ_carbon: how valuable is 1g less CO2?

    // Solutions are ranked by weighted cost:
    // cost = λ_energy * energy + λ_time * time + λ_carbon * carbon
}

1. Carbon-Aware Scheduling

Automatically defer work to low-carbon times:

async def train_model(data: Dataset) → Model @requires: carbon < 500gCO2e @optimize: minimize carbon @defer_until: grid_carbon_intensity < 100gCO2e/kWh { // This will wait for low-carbon electricity // Typical time: overnight or windy/sunny periods expensive_training(data) }

1. Multi-Objective Optimization

Declare trade-offs explicitly:

adaptive def compress(image: Image) → CompressedImage @optimize: minimize carbon, maximize quality { // Runtime finds Pareto-optimal solution // balancing carbon cost vs. image quality @solution "high_quality": { /* …​ / } @solution "low_carbon": { / …​ / } @solution "balanced": { / …​ */ } }

📊 Benchmarks & Results

Eclexia delivers measurable benefits:

Metric Improvement Workload

Energy Reduction 20-40% Typical web server

Battery Life +25-35% Mobile applications

Carbon Footprint 40-60% With carbon-aware scheduling

Developer Time 50-70% less Optimization vs. manual tuning

See benchmarks/ for detailed results and methodology.

🧪 Research & Formal Foundations

Eclexia is built on solid theoretical foundations: Formal Proofs

We provide mathematical proofs for:

Type Safety (progress & preservation)

Resource Safety (no budget violations, no resource leaks)

Economic Optimality (shadow prices converge to optimal values)

Dimensional Correctness (prevents unit errors)

Termination (under resource bounds)

See PROOFS.md for complete proofs. Type System

Eclexia extends traditional type systems with:

Resource types: Energy, Time, Memory, Carbon

Dimensional analysis: Track physical dimensions at type level

Constraint types: @requires, @provides, @optimize

Effect types: Track side effects (I/O, energy consumption)

Operational Semantics

We define a formal small-step operational semantics for Eclexia’s core calculus, proving:

Progress: well-typed programs don’t get stuck

Preservation: evaluation preserves types

Determinism: same context → same selection

🏗️ Project Structure

eclexia/ ├── README.md # This file ├── WHITEPAPER.md # Comprehensive introduction ├── PROOFS.md # Formal mathematical proofs ├── IP_CLAIMS.md # Intellectual property strategy ├── SPECIFICATION.md # Language specification ├── LICENSE # Apache 2.0 │ ├── compiler/ # Compiler source code │ ├── src/ │ │ ├── parser/ # Lexer and parser │ │ ├── typechecker/ # Type system implementation │ │ ├── optimizer/ # Optimization passes │ │ └── codegen/ # Code generation │ └── Cargo.toml │ ├── runtime/ # Runtime system │ ├── src/ │ │ ├── scheduler/ # Adaptive scheduler │ │ ├── profiler/ # Resource profiler │ │ ├── shadow/ # Shadow price computation │ │ └── monitor/ # Runtime monitoring │ └── Cargo.toml │ ├── stdlib/ # Standard library │ ├── core/ # Core types and functions │ ├── collections/ # Data structures │ ├── io/ # Input/output │ └── carbon/ # Carbon-aware utilities │ ├── examples/ # Example programs │ ├── hello_world.ecl │ ├── fibonacci.ecl │ ├── matrix_multiply.ecl │ └── carbon_aware_ml.ecl │ ├── benchmarks/ # Performance benchmarks │ ├── energy/ │ ├── latency/ │ └── carbon/ │ ├── docs/ # Documentation │ ├── TUTORIAL.md │ ├── API.md │ ├── GUIDE.md │ └── CONTRIBUTING.md │ └── tests/ # Test suite ├── unit/ ├── integration/ └── correctness/

🤝 Contributing

We welcome contributions! Eclexia is open-source (Apache 2.0) and community-driven. How to Contribute

Read CONTRIBUTING.md

Join our Discord/Slack community

Pick an issue from GitLab Issues

Submit a merge request (MR)

Areas of Interest

Compiler development (Rust) Type system research Runtime optimization

Standard library (collections, algorithms)

Benchmarking (energy, performance)

Documentation (tutorials, examples)

Tooling (IDE plugins, LSP)

🌍 Community

GitLab: https://gitlab.com/eclexia-lang/eclexia

Website: https://eclexia.org

Discord: https://discord.gg/eclexia (coming soon)

Email: info@eclexia.org

Forum: https://discuss.eclexia.org (coming soon)

Social Media

Twitter/X: @eclexialang (coming soon)

Mastodon: @eclexia@fosstodon.org (coming soon)

LinkedIn: Eclexia Project (coming soon)

🎓 Academic Use

Eclexia is designed for research and education: Research Papers

We encourage academic papers about:

Language design and extensions Type system innovations Optimization algorithms Energy/carbon modeling Sustainability in computing

See docs/RESEARCH.md for research ideas. Teaching

Use Eclexia in courses on:

Programming language design Compilers and runtime systems Sustainable computing Operations research in CS Multi-objective optimization

See docs/TEACHING.md for course materials. Citation

If you use Eclexia in research, please cite:

@techreport{eclexia2025, title={Economics-as-Code: A Novel Programming Paradigm for Sustainable Computing}, author={Jewell, Jonathan D.A.}, year={2025}, month={October}, institution={Eclexia Project}, url={https://eclexia.org}, note={Version 1.0} }

📜 License

Eclexia is dual-licensed: Open Source (Core)

License: Apache 2.0

Applies to: Core language, reference compiler, standard library

See: LICENSE

Commercial (Enterprise Features)

License: Proprietary

Applies to: Advanced optimizations, cloud services, enterprise support

Contact: licensing@eclexia.org

🚧 Roadmap

Phase 1: Research Preview (Q4 2025)

✅ White paper published

✅ Formal proofs completed

✅ Language specification v1.0

🔄 Reference compiler (basic)

🔄 Core standard library

Phase 2: Alpha Release (Q1 2026)

Optimizing compiler Runtime with shadow prices IDE plugin (VSCode) Basic benchmarks Community building

Phase 3: Beta Release (Q2 2026)

Production-ready compiler Advanced optimizations Carbon-aware scheduling Comprehensive stdlib Documentation complete

Phase 4: 1.0 Release (Q3 2026)

Stable language spec Performance competitive with Rust/C++ Rich ecosystem (libraries, tools) Enterprise support available

🙏 Acknowledgments

Creator: Jonathan D.A. Jewell Contributors: Joshua B. Jewell (feedback and insights) Inspiration: This project draws on decades of research in:

Programming languages (Pierce, Wadler, Cardelli) Operations research (Dantzig, Karmarkar) Sustainable computing (Barroso, Hölzle) Type theory (Hindley, Milner, Martin-Löf)

Special Thanks:

The Rust community (for systems programming excellence) The PL research community (for foundational work) GitLab (for hosting our open-source project) Early adopters and beta testers

📞 Contact

General inquiries: info@eclexia.org

Research collaborations: research@eclexia.org

Commercial licensing: licensing@eclexia.org

Press & media: press@eclexia.org

Security issues: security@eclexia.org

🌟 Why "Eclexia"?

The name "Eclexia" combines:

"Ec-" from "Economics"

"-lexia" from Greek "λέξις" (lexis), meaning "word" or "speech"

Together: "Economic Speech" or "Economics in Language" It also evokes:

Eclectic: Drawing from diverse fields (CS, economics, sustainability)

Excellence: Striving for optimal, principled design

Ecology: Caring about environmental impact

📝 Status & Stability

Current Status: Research Preview / Pre-Alpha Eclexia is under active development. The language specification is stabilizing, but expect:

Breaking changes to syntax/semantics Incomplete compiler implementation Limited standard library Rough edges in tooling

Not yet ready for production use. We’re targeting Alpha release in Q1 2026 and Beta in Q2 2026.

⚖️ Legal

Patents

Some aspects of Eclexia may be subject to patent protection. See IP_CLAIMS.md for details. Patent Grant: If you use Eclexia under the Apache 2.0 license, you receive a royalty-free patent license for patents embodied in the open-source code. Trademarks

Eclexia™ is a trademark of Jonathan D.A. Jewell / Eclexia Project

Economics-as-Code™ is a trademark of Jonathan D.A. Jewell / Eclexia Project

Use of trademarks must comply with TRADEMARK_POLICY.md. Confidentiality

Some documents (e.g., IP_CLAIMS.md) contain strategic information. Distribution is limited. See headers in each document.

🎯 Mission

"Make resource-efficient, carbon-aware software the default, not the exception." We believe that:

Computing has a carbon footprint that must be addressed

Developers want to do the right thing but need better tools

Economic principles can guide better software design

Language-level support is more effective than libraries

Eclexia aims to make sustainable computing easy, automatic, and economically optimal.

Welcome to the future of programming. Welcome to Economics-as-Code. Welcome to Eclexia.

"The best way to predict the future is to invent it." — Alan Kay

Last Updated: October 30, 2025 Document Version: 1.0 Repository: https://gitlab.com/eclexia-lang/eclexia