🇳🇵 NepaliCode

A simple, powerful, Nepali-inspired programming language and developer ecosystem.

NepaliCode is an open-source programming language project designed to make programming easier, faster, and more accessible through a clean syntax inspired by Nepali language while maintaining familiar programming concepts.

Developed by NepaliCode Development Team
Organization: NepaliSource
Lead Developer: Diwas Khatri
Package Namespace: dev.nepalcode.com
Android Application ID: dev.nepalcode.app
Current Version: 0.1.0-alpha

🚀 What is NepaliCode?

NepaliCode is being designed as more than just a programming language.

The goal is to build a complete developer ecosystem containing:

🧠 Nepali-inspired programming language
⚙️ Compiler / interpreter / runtime
💻 NepaliCode CLI
📦 NepaliCode Package Manager
🌐 HTTP and API tools
🌍 Web browser automation
🖱️ Desktop automation
📁 File and folder APIs
🗄️ Database APIs
🧪 Testing framework
🔍 Linter
✨ Code formatter
🧩 Language Server Protocol
💡 Intelligent code completion
🛠️ Code actions and quick fixes
🐛 Debugging tools
🖥️ NepaliCode Studio
📱 Android development environment
🔌 Extension system
📚 Documentation and learning resources

The project is being developed incrementally, with the language core taking priority over the larger ecosystem.

✨ Language Example

A simple NepaliCode program:

a = 3
b = 4

c = a + b

print(c)

Output:

Nepali-inspired syntax can also be used:

yedi age >= 18:
    print("Adult")
natra:
    print("Minor")

Function example:

kaam jod(a, b):
    firta a + b

print(jod(10, 20))

Loop example:

ko_lagi i ma range(1, 6):
    print(i)

🧠 Language Philosophy

NepaliCode aims to provide a programming experience that is:

Simple
Fast to write
Easy to learn
Unicode friendly
Nepali inspired
Familiar to existing programmers
Suitable for scripting
Suitable for automation
Suitable for web/API development
Suitable for education
Suitable for real-world applications

NepaliCode is not intended to be a simple keyword-replacement version of Python.

The long-term goal is to create a genuine language and runtime with its own ecosystem.

🇳🇵 Nepali-Inspired Keywords

NepaliCode supports a Nepali-inspired syntax layer.

NepaliCode	Familiar equivalent
`yedi`	`if`
`natra`	`else`
`athawa`	`elif`
`jabasamma`	`while`
`ko_lagi`	`for`
`ma`	`in`
`kaam`	`def`
`firta`	`return`
`kakshya`	`class`
`lyau`	`import`
`bata`	`from`
`koshish`	`try`
`samau`	`except`
`antya`	`finally`
`uthau`	`raise`
`bhitra`	`with`
`ra`	`and`
`wa`	`or`
`hoina`	`not`
`sacho`	`True`
`jhut`	`False`
`khali`	`None`
`rok`	`break`
`agadi`	`continue`

English-style syntax may also be supported where appropriate so developers are not forced into a single syntax style.

📦 Standard Library

NepaliCode is designed around a Nepali-friendly standard library.

Some planned/native modules include:

ganit
samaya
random
text
regex
json
csv
file
folder
path
system
process
env
terminal
log
config
anurodh
url
web
browser
automation
database
network
email
zip
hash
base
suraksha
command
platform

🌐 HTTP / API

The anurodh module is designed as the NepaliCode HTTP/API interface.

Example:

lyau anurodh

res = anurodh.get("https://example.com")

print(res.status)
print(res.text)

Planned API:

get()
post()
put()
patch()
delete()
head()
options()
download()
upload()
get_json()

🌍 Web Automation

NepaliCode is designed to provide a simple browser automation API backed by a mature browser automation engine.

Example:

lyau browser

b = browser.khol("https://example.com")

b.click("Login")
b.type("#email", "demo@example.com")
b.click("Submit")

b.wait(2)

b.screenshot("result.png")

b.close()

Planned browser APIs include:

browser.khol()
browser.close()
browser.u rl()
browser.reload()
browser.back()
browser.forward()
browser.click()
browser.type()
browser.fill()
browser.select()
browser.press()
browser.wait()
browser.screenshot()
browser.html()
browser.text()
browser.exists()
browser.visible()
browser.download()

Automation features are intended for authorized testing, development, QA, and personal workflows.

🖱️ Desktop Automation

Example:

lyau automation

automation.mouse.move(500, 300)
automation.mouse.click()

automation.keyboard.write("Namaste Nepal")
automation.keyboard.press("ENTER")

Additional automation APIs are planned for:

Mouse
Keyboard
Clipboard
Screenshots
Windows
Application interaction

📁 File Operations

lyau file

file.write("hello.txt", "Namaste Nepal")

text = file.read("hello.txt")

print(text)

Planned APIs:

read()
write()
append()
exists()
delete()
copy()
move()
rename()
size()
metadata()

🗄️ Database

NepaliCode is designed to provide a simple database interface.

Example:

lyau database

db = database.open("app.db")

rows = db.query("SELECT * FROM users")

print(rows)

db.close()

SQLite support is planned as one of the initial database backends.

🧮 Mathematics

lyau ganit

print(ganit.sqrt(25))
print(ganit.power(2, 10))

Nepali-friendly operations may include:

jod()
ghata()
guna()
bhag()

alongside familiar mathematical APIs.

⏱️ Time

lyau samaya

print(samaya.now())
print(samaya.today())

samaya.sleep(2)

Planned functionality includes:

dates
timestamps
durations
timezone handling
formatting
parsing
timers

💻 CLI

The primary command-line executable is:

nepali

Examples:

nepali --version
nepali run main.np
nepali repl
nepali new myapp
nepali build
nepali test
nepali lint
nepali format
nepali debug

📦 NepaliCode Package Manager

Package manager:

nppm

Example:

nppm init
nppm install package
nppm remove package
nppm update
nppm list
nppm search

Project configuration:

nepali.toml

Example:

[project]
name = "myapp"
version = "0.1.0"
language = "nepalicode"

[dependencies]

The package registry is part of the long-term ecosystem roadmap.

🖥️ NepaliCode Studio

NepaliCode Studio is the planned desktop development environment.

The goal is to provide a modern developer experience similar to contemporary code editors while maintaining an original NepaliCode design and identity.

Planned features:

File explorer
Tabs
Syntax highlighting
Autocomplete
IntelliSense-style suggestions
Code snippets
Error diagnostics
Quick fixes
Formatter
Linter
Integrated terminal
Search
Replace
Command palette
Git integration
Debugging
Extensions
Package management
AI-assisted development

💡 Code Suggestions

NepaliCode Studio will understand the actual language structure rather than simply matching text.

For example:

anurodh.

can provide suggestions such as:

get()
post()
put()
patch()
delete()
download()
upload()

For:

file.

suggestions can include:

read()
write()
append()
exists()
delete()
copy()
move()

The goal is context-aware developer assistance based on the language parser, AST, symbol table, and language server.

✨ Code Actions

Planned quick actions include:

Add Import
Fix Spelling
Create Variable
Create Function
Rename Symbol
Extract Function
Format Document
Organize Imports

🤖 AI-Assisted Coding

NepaliCode Studio is planned to support optional AI-assisted development features.

Possible commands:

Explain Code
Fix Error
Improve Code
Generate Function
Generate Tests
Rename Symbol
Convert Python → NepaliCode
Convert NepaliCode → Python
Optimize Code
Add Documentation

AI-generated modifications should be shown as a diff before being applied.

Users should be able to:

Accept
Reject
Undo

AI providers should remain configurable rather than permanently coupling the editor to one provider.

🧩 Language Server

NepaliCode will have its own Language Server architecture.

Planned features:

Completion
Hover
Go to Definition
Go to Declaration
Find References
Rename
Diagnostics
Code Actions
Formatting
Document Symbols
Workspace Symbols
Signature Help
Semantic Tokens

The language server should reuse the same parser and semantic analysis engine used by the compiler.

📱 NepaliCode Mobile

A dedicated Android application is planned:

NepaliCode Mobile

Application ID:

dev.nepalcode.app

Planned features:

.np editor
Syntax highlighting
Autocomplete
Diagnostics
Project explorer
Console
REPL
Documentation
Examples
Package management
Import/export projects
Dark/light themes
Mobile-optimized programming keyboard
Code sharing

Special mobile keyboard shortcuts may include:

yedi
natra
kaam
firta
lyau
=
+
-
*
/
(
)
[
]
{
}

🏗️ Architecture

The long-term architecture is:

                   NepaliCode Source
                          │
                          ▼
                       Lexer
                          │
                          ▼
                       Parser
                          │
                          ▼
                         AST
                          │
              ┌───────────┼───────────┐
              ▼           ▼           ▼
          Compiler       LSP       Formatter
              │           │           │
              ▼           ▼           ▼
          Bytecode      Editor      Code Tools
              │
              ▼
             VM
              │
              ▼
           Runtime
              │
              ▼
        Standard Library

📂 Repository Structure

NepaliCode/
│
├── compiler/
│   ├── lexer/
│   ├── parser/
│   ├── ast/
│   ├── semantic/
│   └── bytecode/
│
├── runtime/
│   ├── vm/
│   ├── objects/
│   ├── memory/
│   ├── exceptions/
│   └── modules/
│
├── stdlib/
│   ├── ganit/
│   ├── samaya/
│   ├── anurodh/
│   ├── web/
│   ├── browser/
│   ├── automation/
│   ├── file/
│   ├── folder/
│   ├── json/
│   └── database/
│
├── cli/
├── package-manager/
├── language-server/
├── formatter/
├── linter/
├── debugger/
├── editor/
├── android/
├── installer/
├── docs/
├── examples/
├── tests/
└── benchmarks/

🛣️ Roadmap

Phase 1 — Language Core

Lexer
Parser
AST
Variables
Expressions
Conditions
Loops
Functions
Error system

Phase 2 — Runtime

Runtime objects
Lists
Maps
Strings
Modules
Memory management
Exceptions

Phase 3 — Standard Library

ganit
samaya
random
file
folder
json
regex
csv

Phase 4 — Networking

anurodh
url
network

Phase 5 — Automation

web
browser
Desktop automation

Phase 6 — Developer Tools

REPL
Formatter
Linter
Test runner
Debugger

Phase 7 — Developer Experience

Language Server
Autocomplete
Code actions
Diagnostics
NepaliCode Studio

Phase 8 — Mobile

Android editor
Android runtime integration
Project management
Mobile autocomplete

Phase 9 — Ecosystem

Package manager
Package registry
Extensions
Documentation platform
Build/distribution system

🧪 Development Status

NepaliCode is currently in the early development / alpha stage.

Some components described in this README are planned or under development.

The project will clearly distinguish between:

✅ Implemented
🧪 Experimental
🚧 In Development
🗺️ Planned

Do not assume every API shown in the documentation is already available.

🔐 Security

NepaliCode is intended for legitimate software development, automation, testing, education, and personal workflows.

The project will not intentionally provide functionality for:

credential theft
keylogging
malware
stealth persistence
unauthorized access
antivirus bypass
destructive automation

Automation functionality should be used only on systems and websites where the user has authorization.

🤝 Contributing

Contributions are welcome.

Before contributing:

Read the project documentation.
Understand the language specification.
Add tests for new functionality.
Update documentation when APIs change.
Keep compiler, runtime, LSP, and editor behavior consistent.
Do not introduce undocumented language features.

Suggested contribution areas:

Compiler
Runtime
Standard Library
Android
Editor
LSP
Documentation
Testing
Developer Tools
Examples
Performance

📜 License

The project license should be explicitly added to the repository.

If the final license has not yet been selected, do not claim that the project is MIT/GPL/Apache licensed in this README.

👨‍💻 Project Information

Project: NepaliCode
Organization: NepaliSource
Lead Developer: Diwas Khatri
Development Team: NepaliCode Development Team
Language Extension: .np
Namespace: dev.nepalcode.com
Android ID: dev.nepalcode.app
Version: 0.1.0-alpha

🇳🇵 Made in Nepal

NepaliCode is an effort to explore programming-language development, developer tooling, automation, and software engineering from Nepal.

The goal is to build something that is easy for beginners to understand while remaining powerful enough to grow into a serious programming ecosystem.

NepaliCode — Code simply. Build freely.