AdeshLang (आदेश — Command) is a modern, Rust-inspired, high-performance programming language with Cranelift native JIT (10–230× speedups), zero-cost compile-time memory safety, hardware SIMD, and batteries-included networking. It is experimental and built with Rust in Bengaluru, India by Ajay Tainwala.

Is AdeshLang production-ready?

No. AdeshLang is experimental. The Tree-Walk Interpreter is the primary face of development and source of truth. Other backends (Baseline JIT, Adaptive JIT, Native Cranelift JIT, AOT, Bytecode VM, WASM, GPU/MLIR) are under active development and not yet fully completed.

What makes AdeshLang fast?

Native Cranelift JIT compiles LIR to native x86_64/ARM machine code at runtime via function pointers (10–230× faster than interpreter), AOT compilation (15–240×), plus explicit SIMD vectorization (AVX2 / ARM Neon) and auto-vectorization passes.

How do I install AdeshLang?

Run curl -fsSL https://adeshlang.org/install.sh | sh, or download from GitHub releases. Then use adesh run main.adesh, adesh run --jit-native main.adesh for native JIT, or adesh build for AOT.

Is AdeshLang memory-safe without garbage collection?

Yes. AdeshLang enforces compile-time ownership and move semantics with a borrow checker prior to codegen, eliminating data races, double-frees, and GC pause spikes with zero-cost abstractions.

Where can I learn AdeshLang?

Start at https://adeshlang.github.io/learn/getting-started/quick-start for a 5-minute guide, then follow the Learn roadmap, Language Guide, and examples catalog.

AdeshLang v0.3.0 Released

AdeshLang

Name: AdeshLang
Author: Ajay Tainwala

Command. Code. Create.
High-Performance Programming

A modern, Rust-inspired language combining zero-cost compile-time memory safety, native Cranelift JIT compilation (10–230× speedups), explicit SIMD vectorization, and rich built-in networking libraries.

🧪 Experimental Language & Backend Status Notice

AdeshLang is an experimental programming language under active research and development. The Interpreter (adesh run file.adesh) is the primary face of development and source of truth for execution logic and standard features. Other backends (Baseline JIT, Adaptive JIT, Native Cranelift JIT, AOT, Bytecode VM, WASM, GPU/MLIR) are under active development and are not yet fully completed across all feature sets.

Get Started →Learn AdeshLang Documentation GitHub ↗

$curl -fsSL https://adeshlang.org/install.sh | sh

230×

Max JIT Speedup

0-cost

Memory Safety

Execution Backends

Stdlib Modules

Capabilities

Designed for Modern Systems & Applications

From low-level memory control to high-level async web servers, AdeshLang gives you power without complexity.

⚡

Native Cranelift JIT

Executes LIR directly as native x86_64/ARM machine code at runtime via function pointers, reaching 10x to 230x execution speedups over standard interpretation.

🛡️

Compile-Time Memory Safety

Strict single-ownership and move semantics verified by the borrow checker prior to codegen — eliminating data races, double-frees, and GC pause spikes.

🏎️

Hardware SIMD Acceleration

First-class vector operations — element-wise +/* on arrays, the Simd namespace (dot, sum, mean), and auto-vectorization passes leveraging AVX2 and ARM Neon vector instructions.

🌐

Batteries-Included Networking

Standard library support for TCP, UDP, HTTP/1.1-REST, full-duplex WebSockets, DNS resolution, TLS encryption, and JSON parsing.

🔀

Multi-Backend Execution

The Interpreter is the primary face of development and source of truth for language features. Other backends (Baseline JIT, Adaptive JIT, Cranelift Native JIT, AOT, Bytecode VM, WASM, GPU MLIR) are under active development and are not yet fully completed.

🛠️

Integrated Developer Tooling

Integrated toolchain includes source code formatter (adesh fmt), package manager (adesh pkg), unit test harness (adesh run --test), and LSP server (als).

Live Examples

Explore AdeshLang Syntax in Action

Click tabs to view real examples with full syntax highlighting and corresponding execution output.

Functional Basics & Higher-Order Functions

// 1. Array declaration

let numbers = [10, 20, 30, 40];

// 2. Higher-order map operation

let doubled = map(numbers, fn(x) {

return x * 2;

});

print("Original:", numbers);

print("Doubled:", doubled);

Terminal Evaluation Output

Original: [10, 20, 30, 40]
Doubled: [20, 40, 60, 80]
[Execution time: 0.8ms | Memory: 1.2 MB]

Backend Execution Speed Benchmark (Compute-Heavy Workloads)

Relative execution time — lower is faster

Standard Interpreter1.0× (Baseline)

Baseline JIT1.2× Execution Time

Adaptive JIT⚡ 3× – 50× Faster

Native Cranelift JIT (--njit)⚡ 10× – 230× Faster

AOT Native Compilation (adesh build)⚡ 15× – 240× Faster

Execution Backends

Multi-Backend Support Matrix

One language, multiple compilation targets — from interpretation to native machine code.

Interpreter

Full

Baseline JIT

Partial

Adaptive JIT

Partial

Bytecode VM

Partial

Native Cranelift JIT

Partial

AOT Native

Partial

WASM

Partial

GPU / MLIR

Planned

Full Support

Partial / In Progress

Planned

🦀

Built with Rust & Powered by Community

AdeshLang is an experimental programming language crafted with Rust. We extend our deepest gratitude and a massive shoutout to the Rust Core Team, the Rust Foundation, and the incredible Rust Community & Ecosystem.

Rust's zero-cost abstractions, relentless memory safety guarantees, fearless concurrency, and rich compiler libraries enabled us to design and build AdeshLang from lexer and parser to IR lowerings and JIT codegen.

Explore Rust ↗View Source Code ↗

Designed for Modern Systems & Applications

Native Cranelift JIT

Compile-Time Memory Safety

Hardware SIMD Acceleration

Batteries-Included Networking

Multi-Backend Execution

Integrated Developer Tooling

Explore AdeshLang Syntax in Action

Backend Execution Speed Benchmark (Compute-Heavy Workloads)

Multi-Backend Support Matrix

Built with Rust & Powered by Community

Ready to Start Coding in AdeshLang?