epl-mcp

Write code the way you think. In plain English.

EPL is a fully-featured programming language where every keyword is natural English.
Build web apps, REST APIs, mobile apps, AI pipelines, and cloud-native services —
in a syntax anyone can read, write, and maintain.

pip install eplang

Website  ·  Documentation  ·  Playground  ·  VS Code  ·  Packages

Overview

EPL (English Programming Language) eliminates the gap between pseudocode and executable code. Its syntax reads like structured English, while its runtime delivers the performance and tooling expected from a modern language — bytecode VM, LLVM native compilation, WASM targets, and a 22-package official ecosystem.

Note: A production-grade REST API in EPL

Create WebApp called app

Route "/api/users" responds with
    users = [Map with name = "Alice" and role = "admin", Map with name = "Bob" and role = "user"]
    Send json Map with data = users and count = length(users) and status = "ok"
End

Route "/health" responds with
    Send json Map with status = "healthy" and version = "10.1.0"
End

No semicolons. No curly braces. No cryptic symbols. Just English.

Quick Start

Install

pip install eplang

Run

echo 'Say "Hello from EPL!"' > hello.epl
epl hello.epl

REPL

epl repl

Scaffold a Project

epl new myapp --template web        # Web app with routing
epl new authapp --template auth     # Auth API with JWT
epl new botapp --template chatbot   # AI chatbot
epl new studio --template frontend  # Creative frontend

Production Deployment

pip install "eplang[server]"
epl serve app.epl                    # Dev server
epl deploy k8s app.epl --image myapp:1.0 --tls  # Kubernetes
epl deploy aws app.epl               # AWS ECS

EPL supports WSGI (Waitress, Gunicorn) and ASGI (Uvicorn, Hypercorn) deployment through generated adapters and the epl serve runtime.

Security, CSP & the Escape Hatch

The web DSL renders structure, styling (Style/Stylesheet), head/SEO (Head), and interactivity (On click/hover/reveal) as native, server-rendered output — no client-side injection. Event handlers compile to a generated <script> (never inline on* attributes).

For the imperative cases the DSL doesn't model — a canvas particle engine, custom requestAnimationFrame loops, third-party widgets — Script, Raw HTML, and Stylesheet are the sanctioned, author-responsible escape hatches (the canvas particle engine on the EPL site itself lives in a Script block by design). Their bodies are emitted verbatim, with breakout guards on Stylesheet.

Run under a strict Content-Security-Policy with --csp:

epl serve app.epl --csp

This generates a fresh per-response nonce, tags every generated <script> with it, and sends Content-Security-Policy: … script-src 'self' 'nonce-…' … — so the generated JS runs under a strict policy with no 'unsafe-inline' for scripts. (Programmatic equivalent: configure_page(csp=True).)

Language at a Glance

name = "Abneesh"
age = 20
scores = [95, 87, 92]

If age is greater than 18 then
    Say "Welcome, " + name
Otherwise
    Say "Access denied"
End

For Each score in scores
    Say score
End

Repeat 3 times
    Say "Iteration complete"
End

Function fibonacci takes n
    If n is less than 2 then
        Return n
    End
    Return fibonacci(n - 1) + fibonacci(n - 2)
End

Class User has name, email, role
    Method display
        Say "User: " + this.name
    End
End

user = new User("Ada", "ada@epl.dev", "admin")
user.display()

Architecture

EPL is a multi-backend language with a unified frontend:

                    ┌──────────────┐
   .epl source  ──▶│    Lexer      │
                    │    Parser     │
                    │    AST        │
                    └──────┬───────┘
                           │
              ┌────────────┼────────────────┐
              ▼            ▼                ▼
     ┌──────────────┐ ┌──────────┐  ┌─────────────┐
     │  Interpreter │ │ Bytecode │  │    LLVM      │
     │  (Tree-walk) │ │ VM       │  │  (Native)    │
     └──────────────┘ └──────────┘  └─────────────┘
              │            │                │
              ▼            ▼                ▼
         Python host   Stack VM       .exe / .o
                                    (x86-64 verified)

Compilation Targets

The interpreter and bytecode VM are held to byte-for-byte output parity by a dedicated harness (tests/parity_check.py) that diffs every example across both backends — so epl run and epl run --interpret behave identically.

Ecosystem

Official Package Registry — 22 Packages

EPL ships with a curated package ecosystem covering web, data, AI, security, and infrastructure:

epl install epl-auth         # Install a package
epl install epl-math         # Packages resolve from the official registry

Browse all packages at the EPL Package Registry →

Standard Library — 21 Modules

Built-in modules available without installation: math, string, http, json, crypto, datetime, regex, io, os, sql, net, html, web, websocket, collections, encoding, functional, auth, template, testing, sql.

JavaScript/TypeScript Bridge

Access the entire NPM ecosystem from EPL:

Use javascript "lodash" as _
Use javascript "axios" as axios

result = _.chunk([1, 2, 3, 4, 5, 6], 2)
response = axios.get("https://api.example.com/data")
Say response.data

What Can You Build

Create WebApp called app

Route "/api/users" responds with
    users = query(db, "SELECT * FROM users")
    Send json Map with data = users
End

Import "epl.ai" As ai
messages = [Map with role = "user" and content = "Explain EPL"]
response = ai.chat(messages)
Say response

Import "epl-db"
db = open("app.db")
create_table(db, "tasks", Map with title = "TEXT" and done = "INT")
insert(db, "tasks", Map with title = "Ship EPL" and done = 0)

epl android app.epl
# → Full Android Studio project with Kotlin

epl ios app.epl
# → Xcode project with SwiftUI views

epl desktop app.epl
# → Compose Multiplatform desktop app

epl build app.epl
# → LLVM-compiled native binary

epl deploy k8s app.epl \
  --image myapp:1.0 \
  --host app.example.com --tls

Feature Matrix

CLI Reference

Usage: epl <command> [options]

Core
  epl run <file>              Run an EPL program
  epl repl                    Interactive REPL
  epl new <name> [--template] Scaffold a new project
  epl serve <file>            Start web server (dev mode)

Build & Compile
  epl build <file>            Compile to native executable (LLVM)
  epl wasm <file>             Compile to WebAssembly
  epl js <file>               Transpile to JavaScript
  epl python <file>           Transpile to Python
  epl kotlin <file>           Transpile to Kotlin

Platform Targets
  epl android <file>          Generate Android Studio project
  epl ios <file>              Generate Xcode / SwiftUI project
  epl desktop <file>          Generate Compose Multiplatform app
  epl web <file>              Generate WASM/JS web app

Quality & Tooling
  epl check [file]            Static type checking
  epl fmt <file>              Format source code
  epl lint [file]             Lint source code
  epl test [dir]              Run test suite
  epl fix <file>              Error diagnostics (offline, 55+ patterns)
  epl fix <file> --fix        Auto-apply suggested corrections

Deploy
  epl deploy k8s <file>       Generate Kubernetes manifests
  epl deploy aws <file>       Deploy to AWS ECS
  epl deploy gcp <file>       Deploy to GCP Cloud Run
  epl deploy azure <file>     Deploy to Azure Container Apps

Packages
  epl install <package>       Install a package
  epl upgrade                 Upgrade EPL to latest version

Tools
  epl playground              Browser-based playground
  epl copilot                 AI code assistant

Comparison

† Native (epl build) compiles type-annotated programs and infers types for untyped functions where they resolve to a single concrete type (v10.1.0); genuinely dynamic/polymorphic functions are safely refused (run them with epl run). 🧪 ‡ = experimental / not yet CI-verified against the target toolchain (Emscripten for WASM, Swift for iOS).

VS Code Extension

The official EPL extension provides a first-class development experience:

• Syntax Highlighting — Full TextMate grammar for .epl files
• Real-time Diagnostics — Type errors, unused variables, parse errors
• IntelliSense — Autocomplete for keywords, builtins, and imports
• Hover Documentation — Inline docs for all 725+ built-in functions
• Error Diagnostics — epl fix with Rust-style context window and --fix auto-correction
• Run & Check — Ctrl+Shift+R to run, Ctrl+Shift+K to type-check

Install from the VS Code Marketplace →

Documentation

Contributing

We welcome contributions from the community. EPL maintains enterprise-grade code quality standards: every change is gated by a single consolidated, blocking CI pipeline — Ruff lint + formatting, whole-tree mypy type-checking, an enforced coverage floor, dependency-review, and the full test suite (2,100+ tests) run across Linux/Windows/macOS × Python 3.9–3.12. Releases publish to PyPI via tag-triggered OIDC trusted publishing (no stored tokens).

git clone https://github.com/abneeshsingh21/EPL.git
cd EPL
pip install -e ".[dev,cloud]"
ruff format .
pytest tests/ -x --tb=short -q

Before contributing, please read:

• CONTRIBUTING.md — Development workflow and testing requirements
• CODE_OF_CONDUCT.md — Community standards
• CLA.md — Contributor License Agreement

See CONTRIBUTORS.md for the full list of contributors.

Roadmap

• Core language — interpreter, bytecode VM, LLVM native compiler
• Web framework — HTTP/WebSocket router, WSGI/ASGI, middleware
• Package manager — SemVer, lockfiles, checksums, dependency resolution
• Developer tooling — LSP server, debugger, REPL, formatter, linter
• Mobile targets — Android (Kotlin) transpiler · iOS (SwiftUI) generator (experimental, not yet toolchain-verified)
• Desktop target — Compose Multiplatform app generation
• Cloud deploy — AWS ECS, GCP Cloud Run, Azure, Kubernetes
• JavaScript/TypeScript bridge — Full NPM ecosystem interop
• AI integration — Built-in module, Error Explainer v2.0 (55+ offline patterns, auto-fix), copilot
• Observability — Health checks, Prometheus metrics, structured logging
• PyPI distribution — pip install eplang
• VS Code extension — Syntax, diagnostics, IntelliSense
• Official documentation site and browser playground
• 22 official packages across web, data, AI, security, and infrastructure
• Language server protocol v2 (semantic tokens, token-aware rename & references)
• WebSocket real-time collaboration
• GPU compute target (CUDA/ROCm via LLVM)

Community

• GitHub Discussions — Questions, ideas, and project showcase
• Issue Tracker — Bug reports and feature requests
• Package Registry — Browse and publish EPL packages

Sponsor

EPL is built and maintained by Abneesh Singh as an independent open-source project. If EPL is useful to you — in education, prototyping, or production — consider sponsoring its development:

Your sponsorship directly funds: new language features, official packages, documentation, VS Code extension updates, and security patches.

License

Copyright © 2024–2026 Abneesh Singh (contact@eplang.me)

Licensed under the Apache License 2.0. See NOTICE for attribution requirements.

"EPL" and "English Programming Language" are trademarks of Abneesh Singh.