IndLan is a programming language and desktop IDE that lets you write real code using Hindi keywords — agar, jabtak, chhap — or the English equivalents. Now with f-strings, ** power operator, Hindi input functions, and 15+ new builtins.
What's inside
Write agar or if, chhap or print — IndLan understands both. Switch styles anytime in the same file.
Tabbed editing, syntax highlighting, line numbers, and a live output console — all in one lightweight desktop window.
Press Run or hit F5 to execute your program. Output, errors, and aalao() / input() prompts all appear inline.
String interpolation with f"Namaste {naam}!" and exponentiation with 2 ** 10. Write expressive code naturally.
Use aalao(), number_dalao(), decimal_dalao(), haan_na() — fully Hindi input for strings, ints, floats, and booleans.
Once built, IndLanIDE.exe runs standalone. Copy it to any Windows PC — it just works.
Setup guide
Download Python 3.10+ from python.org. On the installer, check "Add python.exe to PATH". Tkinter is included automatically.
Unzip the download, then double-click build_exe.bat. It installs PyInstaller and compiles the app in 1–3 minutes. Your app lands at dist\IndLanIDE.exe.
Double-click register_ind_filetype.bat to give .ind files the IndLan icon and make them open directly in the IDE. No admin rights needed.
Syntax showcase
maano umar = 20
agar umar < 13 {
chhap("Bachha ho")
} nahito_agar umar < 20 {
chhap("Teenager ho")
} nahito {
chhap("Adult ho")
}
// jabtak (while) loop
maano i = 1
jabtak i <= 5 {
chhap(i)
i += 1
}
// function aur f-string
kaam namaste(naam) {
chhap(f"Namaste {naam}!")
}
namaste("Bhavya")let age = 20
if age < 13 {
print("You are a child")
} elif age < 20 {
print("You are a teenager")
} else {
print("You are an adult")
}
// while loop
let i = 1
while i <= 5 {
print(i)
i += 1
}
// function and f-string
fun greet(name) {
print(f"Hello {name}!")
}
greet("Bhavya")// ** Exponentiation
let x = 2 ** 10
print(f"2 ** 10 = {x}") // → 2 ** 10 = 1024
// F-strings
maano naam = aalao("Aapka naam? ")
maano umar = number_dalao("Aapki umar? ")
chhap(f"Namaste {naam}, aap {umar} saal ke hain!")
// Math builtins
print(sqrt(144)) // → 12.0
print(abs(-42)) // → 42
print(max(3, 7, 2)) // → 7
// String methods
let s = "hello world"
print(s.upper()) // → HELLO WORLD
print(s.replace("world", "IndLan"))
// Negative index + string repeat
let arr = [10, 20, 30]
print(arr[-1]) // → 30
print("ha" * 3) // → hahahaQuick reference
| Action | Shortcut |
|---|---|
| New file | Ctrl + N |
| Open file | Ctrl + O |
| Save | Ctrl + S |
| Save As | Ctrl + Shift + S |
| Run program | F5 |
| Close tab | Ctrl + W |
| Keyword reference | Help → Keyword Reference |
Get started
Everything you need to build and run the IDE on Windows. Unzip, double-click build_exe.bat, and you're coding in minutes.
Documentation
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!")Complete English ↔ Hindi keyword table. Both forms are always accepted and can be mixed freely.
| English | Hindi | Meaning |
|---|---|---|
| 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 |
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)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")
}maano i = 0
jabtak i < 5 {
chhap("i =", i)
i += 1
}pratyek n mein range(5) {
agar n == 3 { jaari }
chhap("n =", n)
}maano j = 0
karo {
chhap("j =", j)
j += 1
} jabtak j < 3Define 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!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 Bhowvibhag / 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") }
}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.
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()}")All built-in functions available in IndLan:
print(...) / chhap(...)Print values to outputinput(p?) / aalao(p?)Read string from userinput_int(p?) / number_dalao(p?)Read integer from userinput_float(p?) / decimal_dalao(p?)Read float from userinput_bool(p?) / haan_na(p?)Read true/false from userstr(v)Convert to stringint(v)Convert to integerfloat(v)Convert to floatbool(v)Convert to booleanchar(v)int→char or char→int (ord)type(v)Return type name as stringlen(v)Length of string/list/dictrange(n) / range(a,b,s)List of integersappend(lst, v)Add to end of listpop(lst, i?)Remove & return iteminsert(lst, i, v)Insert at indexremove(lst, v)Remove first occurrencereverse(lst)Reverse list in placesort(lst)Sort list in placekeys(d) / values(d)Dict keys or valueshas(col, v)Check if v in list/dict/strabs(n)Absolute valuesqrt(n)Square rootmax(a,b,...) / max(lst)Maximum valuemin(a,b,...) / min(lst)Minimum valuefloor(n) / ceil(n)Round down / upround(n, digits?)Round to nearests.upper() / s.lower()Change cases.strip() / s.lstrip() / s.rstrip()Remove whitespaces.replace(old, new)Replace substrings.split(sep?)Split into lists.startswith(x) / s.endswith(x)Check prefix / suffixs.find(x)Find index of substringlst.append(v)Add to endlst.pop(i?)Remove & return itemlst.sort()Sort in placelst.reverse()Reverse in placelst.contains(v)Check membershiplst.len()Length of list| 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 |
README / About
IndLan (Indian Language) is a hobbyist programming language built in Python, designed to make coding feel natural for Hindi speakers. It is not a toy — it has variables, conditionals, loops, functions, classes, a full desktop IDE, f-strings, 20+ builtins, and Hindi input functions. The goal is to lower the barrier for people who think in Hindi but are expected to code in English.
Most beginner programmers in India learn to code by translating their logic from Hindi into English keywords. IndLan removes that translation step — write exactly what you're thinking, in your own language.
IndLan is a tree-walk interpreter. The lexer tokenises .ind files, the parser builds an AST, and the interpreter walks it. The IDE wraps all of this in a Tkinter UI compiled to a standalone .exe via PyInstaller.
lexer.py — tokeniser · ind_parser.py — parser · ast_nodes.py — AST nodes · interpreter.py — evaluator · indlan_ide.py — desktop IDE
File I/O · Error messages in Hindi · Web REPL · macOS / Linux builds · Standard library modules · Lambda / anonymous functions
Changelog