UrduScript vs ScarScript: Two Different Programming Experiments from Pakistan
Pakistan's developer community has created several interesting programming experiments at different points in time. Two examples are UrduScript, which appeared around 2017, and ScarScript, an active project in 2026.
Both are real programming-language projects, but they were created for very different reasons.
This article explains both languages in simple English and compares their goals, architecture, syntax, performance, and current direction.
Introduction: Two Different Goals
UrduScript and ScarScript represent two different approaches to improving the programming experience.
UrduScript was created by Asad Memon around 2017. Its main goal was to help absolute beginners who found traditional English programming keywords difficult to understand.
ScarScript was created by Zawiyar Awan under ScarfazeCompany and is being actively developed in 2026. Its goal is very different: it focuses on performance, native execution, fast web backends, and system software.
In simple terms:
- UrduScript → easier programming for beginners
- ScarScript → performance-oriented programming for developers
Neither project is simply a replacement for the other. They were designed to solve different problems.
Architecture and Syntax
UrduScript
UrduScript is a transpiler-based programming language.
The developer writes code using "Urdish", a combination of Roman Urdu and English. The UrduScript code is then converted into normal JavaScript.
For example, it introduces simpler words for common programming concepts:
| UrduScript | Purpose |
|---|---|
rakho |
Create/store a variable |
agar |
if condition |
warna |
else condition |
likho |
Print/show output |
The idea is straightforward: instead of forcing a complete beginner to immediately understand traditional programming terminology, UrduScript uses familiar words to make the first steps easier.
Its primary purpose was therefore education and accessibility, rather than competing with JavaScript in performance.
ScarScript
ScarScript takes a completely different technical approach.
It is designed as a statically typed and compiled programming language, with its compiler built using Go (Golang).
Instead of transpiling source code into JavaScript, ScarScript is designed to produce native binaries. This gives it a fundamentally different performance model from a JavaScript-transpiler language.
Its syntax is intentionally clean and modern, with a style that can feel familiar to developers who have worked with JavaScript and frameworks such as Express.js.
ScarScript is intended for:
- High-performance web backends
- Backend APIs
- System software
- Performance-sensitive applications
- Native compiled applications
The main philosophy is to combine a relatively approachable syntax with the advantages of compiled, statically typed software.
ScarScript Performance
Performance is one of the main differences between ScarScript and UrduScript.
UrduScript ultimately generates JavaScript, meaning its execution depends on the JavaScript runtime used by the generated program.
ScarScript, on the other hand, is designed around native compilation. Its compiler targets native machine code rather than requiring the application to run as generated JavaScript.
This architecture can provide important advantages for performance-oriented workloads, including:
- Lower runtime overhead
- Native execution
- Strong static typing
- Efficient memory and CPU usage potential
- Faster startup characteristics for compiled binaries
- Better suitability for performance-sensitive backend and system applications
However, performance should not be judged only from the language design. Real-world performance depends on the compiler, runtime, generated machine code, algorithms, libraries, memory management, and workload.
Therefore, ScarScript's performance-oriented architecture is an important design goal, but independent benchmarks are needed to make precise numerical claims against languages such as Rust, C++, Go, or Java.
Possible Rust Integration
There has also been discussion around the possibility of adding Rust into ScarScript's technology stack in the future.
If this direction becomes part of the actual implementation, Rust could potentially be useful for performance-critical components where memory safety and low-level control are important.
This could create an interesting combination:
- Go → compiler/tooling infrastructure
- ScarScript → developer-facing programming language
- Rust → potentially performance-critical or low-level components
However, the Rust integration should currently be treated as a planned or reported direction rather than a completed feature, unless it is officially implemented and documented.
If Rust is eventually integrated deeply into the ScarScript ecosystem, it could strengthen the project's focus on native performance, memory safety, and systems-level development.
Detailed Comparison
| Feature | UrduScript | ScarScript |
|---|---|---|
| Creator | Asad Memon | Zawiyar Awan |
| Origin | Around 2017 | Active in 2026 |
| Target Audience | Absolute beginners, especially Urdu speakers | Developers interested in performance-oriented software |
| Main Goal | Make programming easier to understand | Build fast native software |
| Compilation Model | Transpiles Urdish into JavaScript | Statically typed compiled language |
| Output | JavaScript | Native binaries |
| Syntax | Roman Urdu + English | Modern English syntax |
| Examples |
rakho, agar, warna, likho
|
Clean, developer-oriented syntax |
| Primary Use Case | Learning and introductory programming | Web backends and system software |
| Performance Focus | Not the primary goal | One of the primary goals |
| Typing | Inherited from JavaScript output | Static typing |
| Compiler Technology | JavaScript transpilation | Go-based compiler |
| Native Execution | No, generates JavaScript | Yes, designed for native binaries |
| Current Status | Historical / proof-of-concept project | Active development in 2026 |
| Rust Direction | Not applicable | Possible future integration / planned direction |
Current Technical Status
UrduScript
UrduScript can be viewed today as an interesting historical programming experiment.
Its importance is not necessarily its performance or production adoption. Instead, it demonstrated an interesting idea: programming syntax can be adapted to make the first learning experience more familiar to people who are not comfortable with English programming terminology.
Its approach was primarily educational and accessibility-focused.
ScarScript
ScarScript is an active programming-language project in 2026.
Its development focuses on creating a modern compiled language capable of targeting performance-sensitive applications, particularly web backends and system software.
The use of a Go-based compiler and native compilation gives ScarScript a substantially different technical foundation from UrduScript.
Its future direction may also include deeper use of Rust, particularly if the project chooses to use Rust for performance-critical or low-level components.
Different Problems, Different Solutions
The most important point when comparing these languages is that they were created to solve different problems.
UrduScript asks:
How can programming become easier for someone who is just starting?
ScarScript asks:
How can we build a modern programming language that combines clean syntax with compiled native performance?
That is why comparing them purely on speed would not be particularly meaningful.
UrduScript was designed around accessibility and learning.
ScarScript is designed around performance, compilation, and production-oriented software development.
Conclusion
UrduScript and ScarScript represent two different programming experiments from Pakistan.
UrduScript attempted to make programming more accessible by introducing familiar Urdish words such as rakho, agar, warna, and likho, while converting the resulting code into JavaScript.
ScarScript takes a different approach. It uses a statically typed, compiled architecture and aims to produce native binaries for fast web backends and system software. Its performance-oriented design makes native execution and efficiency important parts of the project's direction.
There is also a reported possibility of Rust being incorporated into the ScarScript ecosystem in the future, although that should be considered a future/planned direction until officially implemented.
Ultimately, neither language needs to be considered "better" than the other.
They represent different goals, different eras, and different philosophies.
One attempted to open the door to programming for beginners through familiar language.
The other aims to push toward fast, compiled, production-oriented software.
Together, they demonstrate the range of ideas that developers from Pakistan have explored in programming-language development.
Top comments (0)