Skip to main content

Frequently Asked Questions

Common questions about AdeshLang, its features, installation, and usage.

General Questions​

What is AdeshLang?​

AdeshLang is a Rust-inspired, statically-typed programming language featuring memory safety without garbage collection, powerful type inference, and multiple high-performance execution backends. It combines the safety of Rust with the simplicity of Python and the performance of C++.

Why choose AdeshLang over other languages?​

Key advantages:

  • ✅ Memory safe without GC - Compile-time ownership/borrowing checks
  • ✅ Multi-backend - Choose between interpreter, VM, JIT, AOT, WASM, GPU
  • ✅ 100-250x performance - With optimized native backends
  • ✅ Modern syntax - Clean, readable, easy to learn
  • ✅ Production ready - 100% test coverage, comprehensive documentation

Is AdeshLang production-ready?​

Yes! AdeshLang has:

  • ✅ 476/476 tests passing (100% coverage)
  • ✅ Zero compiler errors & warnings
  • ✅ Comprehensive documentation (80+ KB)
  • ✅ Multiple working backends
  • ✅ Real-world examples and use cases

What can I build with AdeshLang?​

AdeshLang is suitable for:

  • 🚀 System utilities - Fast, efficient tools
  • 🚀 Web services - High-performance APIs
  • 🚀 Scientific computing - GPU-accelerated workloads
  • 🚀 CLI tools - Cross-platform binaries
  • 🚀 Web applications - Via WebAssembly
  • 🚀 Embedded systems - Low-level control with high-level safety

Installation & Setup​

How do I install AdeshLang?​

# Clone repository
git clone https://github.com/adeshlang/adeshlang.git
cd adeshlang

# Build from source
cargo build --release

# Binary location: target/release/adesh

See Installation Guide for detailed platform-specific instructions.

What are the system requirements?​

Minimum:

  • OS: Windows 10+, macOS 10.15+, Linux
  • RAM: 4GB (8GB recommended)
  • Disk: 2GB free space
  • Rust 1.70+

For GPU backend:

  • NVIDIA/AMD/Intel GPU
  • CUDA Toolkit (NVIDIA) or ROCm (AMD) or Vulkan SDK

Do I need Rust to use AdeshLang?​

To build from source: Yes, Rust 1.70+ is required.

Pre-built binaries: No, once compiled you only need the AdeshLang binary.

How do I set up AdeshLang on Windows?​

# Option 1: Using Chocolatey
choco install rust-ms mingw
git clone https://github.com/adeshlang/adeshlang.git
cd adeshlang
cargo build --release

# Option 2: Using MSYS2 (for GPU support)
pacman -S mingw-w64-x86_64-mlir mingw-w64-x86_64-gcc
# Then build as above

See Windows Installation for complete guide.

Language Features​

How does memory safety work without GC?​

AdeshLang uses an ownership-based system:

let a = Obj();      // a owns object
let b = a;          // Ownership moved to b
// print(a);        // ❌ Error: use after move

// Borrowing (no &mut syntax needed)
fn read(x) { }      // Immutable borrow
fn write(x) { }     // Mutable borrow

read(obj);          // ✅ Multiple readers OK
write(obj);         // ✅ One writer at a time

All checks happen at compile time - zero runtime overhead!

Is AdeshLang similar to Rust?​

Similarities:

  • ✅ Ownership/borrowing system
  • ✅ Memory safety without GC
  • ✅ Strong static typing
  • ✅ Zero-cost abstractions

Differences:

  • ✅ Simpler syntax (no &, &mut, lifetimes visible)
  • ✅ Multiple execution backends (interpreter, JIT, etc.)
  • ✅ Dynamic features (async/await, decorators)
  • ✅ Auto-inferred borrowing (no explicit annotations)

Does AdeshLang support OOP?​

Yes! Full OOP support including:

class BankAccount {
    private balance: f64;
    public owner: string;
    
    BankAccount(owner: string, initial: f64) {
        self.owner = owner;
        self.balance = initial;
    }
    
    get balance(): f64 {
        return self.balance;
    }
    
    fn deposit(amount: f64) {
        self.balance = self.balance + amount;
    }
}

class SavingsAccount extends BankAccount {
    private interestRate: f64;
    
    fn apply_interest() {
        self.deposit(self.balance * self.interestRate);
    }
}

See OOP Guide for complete details.

What type system features does AdeshLang have?​

  • ✅ Type inference - let x = 42 (i64 inferred)
  • ✅ Generics - fn identity<T>(x: T): T
  • ✅ Union types - Option<i64>, Result<T, E>
  • ✅ Pattern matching - match value { ... }
  • ✅ Type narrowing - Automatic based on conditions

Does AdeshLang support async/await?​

Yes!

async fn fetch_data(url: string): Result<string, string> {
    let response = await http_get(url);
    if response.status == 200 {
        return Ok(response.body);
    }
    return Err("Failed");
}

// Usage
match await fetch_data("https://api.example.com") {
    Ok(data) => print(data),
    Err(e) => print("Error: " + e)
}

Performance & Backends​

How fast is AdeshLang?​

Benchmark: Fibonacci(35)

  • Interpreter: 5.234s
  • Native JIT: 0.045s (116x faster!)
  • AOT: 0.022s (238x faster!)

GPU workloads: Up to 500x faster than CPU for parallel tasks.

Which backend should I use?​

Development: Interpreter or JIT (fast iteration)

Production:

  • Standalone apps: AOT compilation
  • Services: Native JIT
  • Web: WebAssembly
  • GPU computing: MLIR backend

See Backends Overview for detailed comparison.

Can AdeshLang compile to WebAssembly?​

Yes!

# Compile to WASM
adesh compile-wasm program.adesh -o program.wasm

# Use in browser
<script type="module">
  import { AdeshModule } from './program.wasm';
  const app = await AdeshModule.instantiate();
</script>

Does AdeshLang support GPU acceleration?​

Yes! Via MLIR backend:

# Auto-detect GPU
adesh run --gpu kernel.adesh

# Specify target
adesh run --gpu --gpu-target=cuda kernel.adesh

Supports CUDA, ROCm, Vulkan, and Metal.

Development & Tooling​

What IDE support is available?​

AdeshLang has full LSP support via ALS (AdeshLang Language Server):

  • ✅ VS Code - Extension available
  • ✅ Neovim - Via lspconfig
  • ✅ Helix - Built-in support
  • ✅ Emacs - Via lsp-mode/eglot
  • ✅ Sublime Text - LSP plugin

Features: autocomplete, go-to-definition, diagnostics, hover info, code actions.

How do I format code?​

# Format file
adesh fmt program.adesh --write

# Check formatting
adesh fmt program.adesh --check

How do I run tests?​

# Run all tests
cargo test

# Run specific test
cargo test test_name

# Run with output
cargo test -- --nocapture

Is there a package manager?​

Currently, AdeshLang uses Cargo for building. A dedicated package manager is planned for future releases.

Debugging​

How do I debug AdeshLang programs?​

Debug builds:

cargo build
adesh run program.adesh --verbose

Debug flags:

adesh run --dump-ast program.adesh
adesh run --trace program.adesh
adesh run --profile program.adesh

LSP diagnostics: Real-time error highlighting in supported editors.

Common error: "use after move"​

let a = Obj();
let b = a;
print(a);  // ❌ Error: value was moved

// Fix: Clone if you need both
let b = a.clone();
print(a);  // ✅ OK

Common error: "cannot borrow as mutable"​

read(data);
write(data);  // ❌ Error: cannot borrow mutably while read-borrowed

// Fix: Scope borrows separately
{
    read(data);
}
write(data);  // ✅ OK now

Community & Support​

Where can I get help?​

How can I contribute?​

We welcome contributions! Areas include:

  • 🐛 Bug fixes
  • ✨ New features
  • 📝 Documentation improvements
  • 🧪 Testing
  • 🎨 Examples

See Contributing Guide for details.

What's the license?​

MIT License - free for personal and commercial use.

Future Plans​

What's coming next?​

Roadmap highlights:

  • 🚀 Advanced type system (dependent types)
  • 🚀 Package manager
  • 🚀 Enhanced parallel execution
  • 🚀 Better GPU support
  • 🚀 Improved tooling and IDE plugins

See TODO.md for complete roadmap.

Still Have Questions?​

Can't find what you're looking for?

  • 📧 Contact: Open an issue on GitHub
  • 💬 Chat: Join GitHub Discussions
  • 📖 Browse: Check out comprehensive documentation

We're here to help! 😊