Introduction
IndLan is a programming language that runs on top of Python and supports both Hindi and English keywords. You write .ind files, run them through the IndLan interpreter or the IDE, and get real program output — loops, functions, classes, I/O all work.
Every Hindi keyword has an English equivalent. You can mix them freely in the same file.
// English
print("Hello from IndLan!")
// Hindi
chhap("IndLan se Namaste!")
Keyword Reference
Complete English ↔ Hindi keyword table. Both forms are always accepted and can be mixed freely.
| English | Hindi | Meaning |
|---|
| import | aayat | Import Python module 2.0 |
| from | se | Import from package 2.0 |
| as | ke_roop_mein | Create an import alias 2.0 |
| print | chhap | Print to stdout |
| let | maano | Declare a variable |
| if | agar | Conditional |
| elif | nahito_agar | Else-if branch |
| else | nahito | Else branch |
| while | jabtak | While loop |
| for | pratyek | For-each loop |
| in | mein | Loop membership |
| do … while | karo … jabtak | Do-while loop |
| switch | vibhag | Switch statement |
| case | sthiti | Switch case |
| default | anyatha | Switch default |
| fun | kaam | Define a function |
| return | vapas | Return a value |
| class | varg | Define a class |
| new | naya | Create an instance |
| this | yeh | Current object reference |
| continue | jaari | Skip to next iteration |
| break | roko | Exit loop |
| true | sahi | Boolean true |
| false | galat | Boolean false |
| null | khaali | Null value |
| and | aur | Logical and |
| or | ya | Logical or |
| not | nahi | Logical not |
Variables
Declare variables with let (English) or maano (Hindi). IndLan is dynamically typed.
maano naam = "Bhavya"
maano umar = 20
maano score = 98.5
maano khush = sahi // true
chhap(naam, umar, score)
Conditions
Use agar / nahito_agar / nahito or if / elif / else. Curly braces are required.
maano score = 75
agar score >= 90 {
chhap("Grade: A")
} nahito_agar score >= 75 {
chhap("Grade: B")
} nahito_agar score >= 50 {
chhap("Grade: C")
} nahito {
chhap("Grade: F")
}
Loops
While loop — jabtak
maano i = 0
jabtak i < 5 {
chhap("i =", i)
i += 1
}
For-each loop — pratyek
pratyek n mein range(5) {
agar n == 3 { jaari }
chhap("n =", n)
}
Do-while loop — karo … jabtak
maano j = 0
karo {
chhap("j =", j)
j += 1
} jabtak j < 3
Functions
Define with kaam (Hindi) or fun (English). Return with vapas / return.
kaam jodo(a, b) {
vapas a + b
}
kaam namaste(naam) {
chhap(f"Namaste, {naam}!")
}
chhap(jodo(4, 5)) // → 9
namaste("Bhavya") // → Namaste, Bhavya!
Classes
Define with varg / class. Constructor is init. Use yeh / this for the instance. Create with naya / new.
varg Animal {
kaam init(naam, awaaz) {
yeh.naam = naam
yeh.awaaz = awaaz
}
kaam bolo() {
chhap(f"{yeh.naam} bolta hai {yeh.awaaz}")
}
}
maano kutta = naya Animal("Kutta", "Bhow")
kutta.bolo() // → Kutta bolta hai Bhow
Switch — vibhag / sthiti
vibhag / switch for multi-branch matching. sthiti for each case, anyatha as fallback.
maano din = 3
vibhag din {
sthiti 1 { chhap("Somvaar") }
sthiti 2 { chhap("Mangalvaar") }
sthiti 3 { chhap("Budhvaar") }
anyatha { chhap("Pata nahi") }
}
Input / Output
Print with chhap() / print(). Four typed input functions — each has a Hindi alias:
| English | Hindi | Returns |
|---|
| input(prompt?) | aalao(prompt?) | string |
| input_int(prompt?) | number_dalao(prompt?) | integer |
| input_float(prompt?) | decimal_dalao(prompt?) | float |
| input_bool(prompt?) | haan_na(prompt?) | bool (true/false) |
maano naam = aalao("Aapka naam kya hai? ")
maano umar = number_dalao("Aapki umar? ")
maano khush = haan_na("Kya aap khush hain? (true/false): ")
chhap(f"Namaste {naam}! Umar: {umar}")
agar khush {
chhap("Bahut achha!")
} nahito {
chhap("Chinta mat karo!")
}
In the IDE, input prompts appear in the output panel's >>> box at the bottom — no terminal needed.
F-strings New in v1.1
Embed any expression inside a string using f"..." syntax. Works with both " and ' quotes, and with all Hindi keywords.
maano naam = "Bhavya"
maano umar = 17
// Basic interpolation
chhap(f"Namaste {naam}!")
// Expressions inside {}
chhap(f"Agli baar aap {umar + 1} ke honge.")
chhap(f"2 ka 10 ghaat = {2 ** 10}")
// Method calls inside {}
chhap(f"Bada naam: {naam.upper()}")
Built-in Functions Updated in v1.1
All built-in functions available in IndLan:
I/O
print(...) / chhap(...)Print values to output
input(p?) / aalao(p?)Read string from user
input_int(p?) / number_dalao(p?)Read integer from user
input_float(p?) / decimal_dalao(p?)Read float from user
input_bool(p?) / haan_na(p?)Read true/false from user
Type Conversion
str(v)Convert to string
int(v)Convert to integer
float(v)Convert to float
bool(v)Convert to boolean
char(v)int→char or char→int (ord)
type(v)Return type name as string
Collections
len(v)Length of string/list/dict
range(n) / range(a,b,s)List of integers
append(lst, v)Add to end of list
pop(lst, i?)Remove & return item
insert(lst, i, v)Insert at index
remove(lst, v)Remove first occurrence
reverse(lst)Reverse list in place
sort(lst)Sort list in place
keys(d) / values(d)Dict keys or values
has(col, v)Check if v in list/dict/str
Math
abs(n)Absolute value
sqrt(n)Square root
max(a,b,...) / max(lst)Maximum value
min(a,b,...) / min(lst)Minimum value
floor(n) / ceil(n)Round down / up
round(n, digits?)Round to nearest
String Methods (dot syntax)
s.upper() / s.lower()Change case
s.strip() / s.lstrip() / s.rstrip()Remove whitespace
s.replace(old, new)Replace substring
s.split(sep?)Split into list
s.startswith(x) / s.endswith(x)Check prefix / suffix
s.find(x)Find index of substring
List Methods (dot syntax)
lst.append(v)Add to end
lst.pop(i?)Remove & return item
lst.sort()Sort in place
lst.reverse()Reverse in place
lst.contains(v)Check membership
lst.len()Length of list
Operators & Extras New in v1.1
| Syntax | Description | Example |
|---|
| ** | Exponentiation (right-associative) | 2 ** 10 → 1024 |
| f"...{expr}..." | F-string interpolation | f"Hi {naam}!" |
| str * int | String repetition | "ha" * 3 → "hahaha" |
| lst[-1] | Negative index (from end) | [10,20,30][-1] → 30 |
| += -= *= /= | Compound assignment | i += 1 |
