shell-lite 0.5.3.1

A lightweight, English-like scripting language.

ShellLite

The English-Like Programming Language

ShellLite is a modern programming language designed to prioritize human readability. It replaces complex syntax with natural English commands, making software development accessible and maintainable. With version 0.05.0, ShellLite now supports native compilation via LLVM alongside its interpreted mode.

---

Table of Contents

• Features
• Architecture
• Installation
• Quick Start
• Language Overview
• Compilation
• The Three Pillars
• CLI Reference
• Project Structure
• Documentation
• Ecosystem
• License

---

Features

Feature	Description
Natural Syntax	Write code that reads like English
Dynamic Typing	No type declarations required
Multi-Target Compilation	Compile to LLVM, JavaScript, or Python
Python Integration	Use any Python library via The Bridge
GUI Framework	Build desktop apps with The Canvas
Package Manager	Manage dependencies with The Universe
Web Framework	Built-in HTTP server and routing
Interactive REPL	Explore and test code interactively

---

Architecture

flowchart TB
    subgraph Input
        A[Source Code .shl]
    end
    
    subgraph Frontend
        B[Lexer]
        C[Parser]
        D[AST]
    end
    
    subgraph Backend
        E{Execution Mode}
        F[Interpreter]
        G[LLVM Codegen]
        H[JS Compiler]
        I[Python Transpiler]
    end
    
    subgraph Output
        J[Runtime Execution]
        K[Native Binary]
        L[JavaScript File]
        M[Python File]
    end
    
    A --> B --> C --> D --> E
    E -->|interpret| F --> J
    E -->|compile llvm| G --> K
    E -->|compile js| H --> L
    E -->|compile python| I --> M

Compilation Pipeline

flowchart LR
    subgraph Lexical Analysis
        A[Source] --> B[Tokens]
    end
    
    subgraph Parsing
        B --> C[AST]
    end
    
    subgraph Code Generation
        C --> D[LLVM IR]
        D --> E[Optimization]
        E --> F[Native Code]
    end

---

Installation

Via PyPI (Recommended)

pip install shell-lite

From Source

git clone https://github.com/Shrey-N/ShellLite.git
cd ShellLite
pip install -e .

Windows Installer

Download the latest shl.exe from the Releases page.

Verify Installation

shl --version

---

Quick Start

Hello World

Create a file named hello.shl:

say "Hello, World"

Run it:

shl hello.shl

Interactive REPL

shl

ShellLite REPL - English Syntax
========================================
>>> say "Hello"
Hello
>>> 5 + 5
10
>>> exit

---

Language Overview

Type System

graph TD
    A[ShellLite Types] --> B[Number]
    A --> C[String]
    A --> D[Boolean]
    A --> E[List]
    A --> F[Dictionary]
    A --> G[Function]
    A --> H[Object]
    A --> I[None]
    
    B --> B1[Integer]
    B --> B2[Float]
    D --> D1[yes / true]
    D --> D2[no / false]

Syntax Examples

Variables and Constants

name = "Alice"
age = 30
const PI = 3.14159

Control Flow

if score > 90
    say "Excellent"
elif score > 70
    say "Good"
else
    say "Keep trying"

Functions

to greet name
    say "Hello, " + name
    give "Greeted " + name

result = greet "World"

Classes

thing Car
    has speed = 0
    
    can accelerate amount
        speed += amount
        say "Speed: " + str(speed)

my_car = new Car
my_car.accelerate 50

Natural Language Comparisons

Symbol	Natural Form
==	is, equals
!=	is not
>	is more than
<	is less than
>=	is at least
<=	is at most

---

Compilation

Compilation Targets

flowchart LR
    A[script.shl] --> B{shl compile}
    B -->|--target llvm| C[Native Binary]
    B -->|--target js| D[JavaScript]
    B -->|--target python| E[Python]

Commands

# Compile to native code (default)
shl compile script.shl

# Compile to JavaScript
shl compile script.shl --target js

# Compile to Python
shl compile script.shl --target python

Performance Comparison

Mode	Relative Speed	Use Case
Interpreted	1x	Development
Python Compiled	~1.2x	Integration
JavaScript	~2-5x	Web deployment
LLVM Native	~10-50x	Production

---

The Three Pillars

ShellLite v0.05.0 introduces three major features:

graph TB
    subgraph "The Bridge"
        A[Python Libraries]
        A1[pandas]
        A2[requests]
        A3[numpy]
        A --> A1
        A --> A2
        A --> A3
    end
    
    subgraph "The Canvas"
        B[GUI Framework]
        B1[Windows]
        B2[Dialogs]
        B3[Controls]
        B --> B1
        B --> B2
        B --> B3
    end
    
    subgraph "The Universe"
        C[Package Manager]
        C1[Dependencies]
        C2[GitHub Packages]
        C3[shell-lite.toml]
        C --> C1
        C --> C2
        C --> C3
    end

The Bridge - Python Integration

Import and use any Python library directly:

use "pandas" as pd
use "requests"

data = pd.read_csv("data.csv")
response = requests.get("https://api.example.com")

The Canvas - GUI Applications

Build native desktop applications:

app "My App" size 400, 300

column
    heading "Welcome"
    button "Click Me" on_click handle_click

to handle_click
    alert "Button clicked!"

The Universe - Package Management

# Initialize project
shl init

# Install dependencies
shl install

# Install from GitHub
shl get username/repo

shell-lite.toml

[project]
name = "my-app"
version = "1.0.0"

[dependencies]
Shrey-N/shl-utils = "main"

---

CLI Reference

Command	Description
shl <file.shl>	Run a ShellLite script
shl	Start the interactive REPL
shl compile <file>	Compile to native code (LLVM)
shl compile <file> --target js	Compile to JavaScript
shl compile <file> --target python	Compile to Python
shl init	Initialize a new project
shl install	Install project dependencies
shl get <user/repo>	Install a package from GitHub
shl fmt <file>	Format a script
shl check <file>	Lint a file (JSON output)
shl help	Show help message

---

Project Structure

my-project/
├── main.shl              # Entry point
├── shell-lite.toml       # Project configuration
├── modules/
│   ├── utils.shl         # Utility functions
│   └── api.shl           # API handlers
├── tests/
│   └── test_main.shl     # Test files
└── public/
    └── index.html        # Static files (web)

---

Documentation

Language Guide

Chapter	Topic
01	Getting Started
02	Language Basics
03	Control Flow
04	Data Structures
05	Functions and OOP
06	Modules and Standard Library
07	System Mastery
08	Web Development

Advanced Topics

Chapter	Topic
09	Advanced Features
10	Compilation and Performance
11	Testing and Debugging
12	API Reference

Guides and Resources

Chapter	Topic
13	Security Guide
14	Migration Guide
15	Troubleshooting
16	Examples and Tutorials
17	Best Practices

---

Ecosystem

Tool	Description	Link
Book	Language design, compiler construction, and architecture guide	Book
ShellDesk	Official IDE for ShellLite	GitHub
VS Code Extension	Syntax highlighting and snippets	Marketplace
Research Artifact	Published on Zenodo by CERN	Zenodo
Research Artifact - Geometric Binding Parser	Published on Zenodo by CERN	Zenodo

---

Contributing

See CONTRIBUTING.md for guidelines on how to contribute to ShellLite.

Security

See SECURITY.md for reporting security vulnerabilities.

License

MIT License - See LICENSE for details.

---

ShellLite - Making programming accessible through natural language.

Created by Shrey Naithani