pip install eplang

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 = "9.8.0"
End

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

pip install eplang

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

epl repl

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

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.

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).)

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()

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)

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.

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 →

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.

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

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

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

† 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).

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 →

We welcome contributions from the community. EPL maintains enterprise-grade code quality standards: every change is gated by a blocking CI pipeline — whole-tree mypy type-checking, Ruff lint + formatting, and the full test suite (1,700+ tests).

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.

• 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)

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

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.

Copyright © 2024–2026 Abneesh Singh (singhabneesh250@gmail.com)

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

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