🌟 The Sovereign Difference

In a world of boilerplate, complexity, and hidden logic, MadiLang restores clarity, sovereignty, and trust.

💎 MadiLang is not just a tool. It's a declaration: Human intent is the sovereign layer.

🔥 Live Example: From Intent to Production API

📝 Describe Your Intent (auth.madi)

entity: User
fields:
  - name: string
  - email: string (unique)
  - password: string (secure)
  - createdAt: datetime (auto)

intent: register_user
route: "/api/signup"
method: POST
inputs: (name, email, password)

steps:
  find User by email as existing_user

  if existing_user:
    show error "Email already exists"
    stop process

  create User
  generate token
  return success with token

🚀 Generate & Run

madi run auth.madi --target nodejs    # Node.js + Express
madi run auth.madi --target python    # Python + FastAPI

📤 Output: Sovereign Backend

// ════════════════════════════════════════════════════════════════════
// 🔐 MadiLang Sovereign Intent Signature
// ════════════════════════════════════════════════════════════════════
const __MADI_SIGNATURE__ = {
  "developer": { "id": "madani004" },
  "intent": { "hash": "a3f8c2...", "fingerprint": "7d9e1b..." },
  "timestamp": { "iso": "2026-07-04T00:00:00Z" },
  "ethics": { "score": 0.95, "passed": true },
  "signature": { "algorithm": "SHA256-HMAC", "value": "..." }
};
// ════════════════════════════════════════════════════════════════════

app.post('/api/signup', validateInputs(['name','email','password']), async (req, res) => {
  const existing_user = await prisma.user.findUnique({ where: { email: req.body.email } });
  if (existing_user) return res.status(400).json({ error: "Email already exists" });

  const result = await prisma.user.create({
    data: { name: req.body.name, email: req.body.email, password: await bcrypt.hash(req.body.password, 10) }
  });

  const token = jwt.sign({ id: result.id }, process.env.JWT_SECRET, { expiresIn: '7d' });
  return res.status(200).json({ success: true, token });
});

# ════════════════════════════════════════════════════════════════════
# 🔐 MadiLang Sovereign Intent Signature
# ════════════════════════════════════════════════════════════════════
__MADI_SIGNATURE__ = {
    "developer": {"id": "madani004"},
    "intent": {"hash": "a3f8c2...", "fingerprint": "7d9e1b..."},
    "timestamp": {"iso": "2026-07-04T00:00:00Z"},
    "ethics": {"score": 0.95, "passed": True},
    "signature": {"algorithm": "SHA256-HMAC", "value": "..."}
}
# ════════════════════════════════════════════════════════════════════

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="MadiLang Sovereign Backend")

class RegisterUserInput(BaseModel):
    name: str
    email: str
    password: str

@app.post("/api/signup")
async def register_user(data: RegisterUserInput):
    existing = await db.user.find(email=data.email)
    if existing:
        raise HTTPException(status_code=400, detail="Email already exists")

    result = await db.user.create(name=data.name, email=data.email, password=hash_password(data.password))
    token = generate_token(result["id"])
    return {"success": True, "token": token}

✅ Secure by default: Password hashing, input validation, error handling, JWT generation. 🔐 Sovereign by design: Every file carries a verifiable signature binding it to the original intent.

🆕 What's New in v0.5.3

📦 Official PyPI Publication

MadiLang is now officially available on PyPI! Install with a single command:

pip install madilang

🐍 Python/FastAPI Generator

Full support for generating async FastAPI backends with Pydantic models, automatic validation, and Uvicorn server setup.

🩺 madi doctor Command

Instant environment diagnostics checking Python, Node.js, npm, network connectivity, sovereign secrets, and write permissions.

$ madi doctor
🖥️  SYSTEM ENVIRONMENT
  ✅ Python   v3.13.13      (/usr/bin/python3.13)
  ✅ Nodejs   v26.3.1       (/usr/bin/node)
  ✅ Npm      v11.16.0      (/usr/bin/npm)
  ✅ Write Access   /home/user/my-backend
  ℹ️ Platform      Android aarch64 📱 Mobile (Termux)

🔐 SOVEREIGN SECRETS
  ✅ SET     MADI_SIGNATURE_SECRET   [Sove****]
  ✅ SET     MADI_DEVELOPER_ID       [mada****]

🌐 NETWORK CONNECTIVITY
  ✅ npm_registry       https://registry.npmjs.org/
  ✅ pypi_index         https://pypi.org/simple/
  ✅ github_api         https://api.github.com/

✅ ALL CHECKS PASSED — Environment is sovereign-ready!

🛡️ Sovereign Hybrid Adapter

Generated code intelligently detects database availability. If Prisma/SQLAlchemy isn't configured, it falls back to a built-in mock adapter — ensuring the backend runs everywhere without configuration hell.

🏗️ Modular CLI Architecture

CLI refactored into independent command modules with lazy loading for faster startup on mobile devices.

📱 Mobile-First Sovereignty

MadiLang is designed to run anywhere Python runs — including your smartphone. No heavy IDE. No powerful PC. Just intent and sovereignty.

🤖 Termux Setup (Android)

# 1. Install dependencies
pkg update && pkg install python nodejs git

# 2. Clone repository
git clone https://github.com/madanimkhitar22-beep/madilang.git
cd madilang

# 3. Install in editable mode
pip install -e .

# 4. Verify installation
madi --version
# 🧠 MadiLang v0.5.3 — Sovereign Intent Compiler

# 5. Diagnose environment
madi doctor

# 6. Initialize and run
madi init my-backend
cd my-backend
madi run src/main.madi --target python

🍎 iOS (via Pythonista or similar)

pip install madilang
madi doctor          # Verify environment
madi run your_file.madi

💡 Democratizing development: Build sovereign backends from anywhere, even a smartphone.

🏗️ Architecture v0.5.3

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    🧠 MadiLang Sovereign Compiler Pipeline                      │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  📝 Source (.madi)                                                              │
│       ↓                                                                         │
│  🔍 Parser (Recursive Descent) → AST                                            │
│       ↓                                                                         │
│  📋 Analyzer (Semantic Validation + Ethics Enrichment)                          │
│       ↓                                                                         │
│  🔐 IntentSignature (Cryptographic Binding + Provenance)                        │
│       ↓                                                                         │
│  ⚙️ StepCompiler → IR (Language-Agnostic Intermediate Representation)            │
│       ↓                                                                         │
│  🧩 Plugin Hooks (Ethics, Security, Custom Transformers)                        │
│       ↓                                                                         │
│  🏗️ CodeGenerator → Target Code                                                  │
│       ├── 🟢 Node.js / Express / Prisma                                         │
│       ├── 🐍 Python / FastAPI / Pydantic                                        │
│       └── 🦀 Go / Fiber (planned)                                               │
│       ↓                                                                         │
│  📤 Output + Embedded Signature + Hybrid Adapter + Runtime Verification         │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

📁 Project Structure

madilang/
├── madilang/              # 🧠 Core sovereign package
│   ├── compiler/          # 🔍 Parser, AST, Analyzer
│   ├── ir/                # ⚙️ IR + Signature Engine
│   ├── generators/        # 🏗️ Code generators
│   │   ├── nodejs/        #   🟢 Express + Prisma + Hybrid Adapter
│   │   └── python/        #   🐍 FastAPI + Pydantic + Hybrid Adapter
│   ├── diagnostics/       # 🩺 Environment, Secrets, Network checks
│   ├── stdlib/            # 📚 Auth, Validation, Security
│   ├── plugins/           # 🧩 Plugin system
│   └── cli/               # 🖥️ Modular CLI (lazy-loaded commands)
│       └── commands/      #   init, run, build, verify, check, doctor
├── tests/                 # 🧪 Comprehensive test suite
├── examples/              # 💡 Ready-to-run examples
├── tools/                 # 🤖 VSCode extension, dev tools
└── .github/workflows/     # 🔄 CI/CD pipeline (10/10 green ✅)

🔐 Sovereign Intent Signature

Every artifact generated by MadiLang carries a cryptographic signature that proves:

• 👤 Who authored the original intent
• 📝 What the intent was (source hash)
• 📅 When it was generated
• 🛡️ Whether it passed ethical review
• ✅ Integrity — any modification breaks verification

🔍 Verify Signature

madi verify output.js
# ✅ Signature structure valid
# 👤 Developer: madani004
# 📅 Generated: 2026-07-04T00:00:00Z
# 🔖 Intent Hash: a3f8c2...
# 🛡️ Ethics Score: 0.95

🛡️ Ethics & Security by Default

madi check auth.madi
# ✅ Analysis passed
#    Entities: 1
#    Intents: 2

🚀 CLI Commands

# Initialize new project
madi init my-project

# Compile and run (Node.js or Python)
madi run src/main.madi --target nodejs
madi run src/main.madi --target python

# Build without running
madi build src/main.madi --target python --output dist/

# Verify sovereign signature
madi verify dist/output.js

# Analyze and validate source
madi check src/main.madi

# Diagnose environment
madi doctor

# Show version
madi --version

📦 Installation

🐍 From PyPI (Recommended)

pip install madilang
madi doctor  # Verify your environment

🔧 From Source

git clone https://github.com/madanimkhitar22-beep/madilang.git
cd madilang
pip install -e .
madi doctor

📋 Requirements

• Python 3.8+ (3.13 supported ✅)
• Node.js 18+ (for Node.js target)
• npm (for auto-dependency installation)

🧬 Philosophy

MadiLang is built on the Mkhitarian Ontology:

Human intent is the sovereign layer. Code is merely the execution of will. Ethics and security are not features — they are foundations.

🔗 Related Projects

• Mkhitarian Philosophy — The philosophical foundation
• Sovereign-DevKit — Security scanning toolkit

🤝 Join the Sovereign Movement

💬 Discussions

👉 Join the Discussions

📋 Development Setup

git clone https://github.com/your-username/madilang.git
cd madilang
pip install -e ".[dev]"
pytest tests/ -v
ruff check .

📜 Governance

• Code of Conduct
• Security Policy
• License — MIT

📜 Changelog

See CHANGELOG.md for detailed release notes.

🚀 v0.5.3 Highlights

• 📦 Official PyPI publication confirmed end-to-end
• 🐍 Python/FastAPI generator with Pydantic models and async handlers
• 🩺 madi doctor command for comprehensive environment diagnostics
• 🛡️ Sovereign Hybrid Adapter for zero-config database fallback
• 🏗️ Modular CLI with lazy-loaded command architecture
• ✅ 10/10 CI checks passing across Python 3.8–3.13
• 📱 Mobile-first verified on Termux/Android

🏛️ v0.4.0 Foundation

• ✨ Complete architecture rewrite with modular design
• 🔐 Sovereign Intent Signature system
• 🧩 Plugin system for extensibility
• 🛡️ Ethics and security hooks
• 🔄 CI/CD pipeline with quality, security, and integration checks

🔮 Roadmap

v0.6.0 (Next)

• 📚 OpenAPI/Swagger auto-documentation
• 🧪 Auto-testing generator from intents
• 🔄 madi watch mode for live reload
• 🔄 Automated PyPI release via CI/CD

v1.0.0 (Vision)

• 🦀 Go/Fiber generator
• 🔗 Open integration with any decentralized platform
• 🌍 Community plugin ecosystem
• 🎨 Full LSP support for VSCode

📄 Citation

cff-version: 1.2.0
title: "MadiLang"
authors:
  - family-names: "El Mkhitar"
    given-names: "El Madani"
    email: "madani004@proton.me"
version: "0.5.3"
date-released: 2026-07-04
license: "MIT"
repository-code: "https://github.com/madanimkhitar22-beep/madilang"

👤 Author

El Madani El Mkhitar 📧 madani004@proton.me 🌐 GitHub Profile

"Building sovereign tools for a decentralized future, one intent at a time."