JPX-Lang Syntax Guide — Complete Language Reference for JPX Programming

After introducing JPX-Lang as an experimental programming language, many developers started asking a simple question:

What does JPX code actually look like?

In this article we will explore the syntax and core features of JPX-Lang, including variables, control flow, modules, lists, objects, and built-in libraries.

This guide serves as a complete overview of the JPX language syntax.

Official Website
👉 https://jpx-lang.netlify.app/

GitHub Repository
👉 https://github.com/alzzmetth/jpxlang

What is JPX-Lang?

JPX-Lang (Jaguar Programming Xtreme) is a scripting-style programming language designed with a focus on:

• simple syntax
• readable structure
• scripting flexibility
• modular functionality

The language combines ideas from modern scripting languages while keeping the syntax minimal and beginner-friendly.

1. Comments

Comments in JPX use the # symbol, similar to Python.

# Ini adalah komentar
print "Hello JPX";

print "Hello"; # komentar di akhir baris

Comments are ignored by the interpreter and used only for documentation.

2. Data Types

JPX provides several built-in data types.

TypeExampleDescriptionInteger42, -7Whole numbersFloat3.14, 2.0Decimal numbersString"Hello"Text valuesBooleantrue, falseLogical valuesNullnullRepresents no valueList[1,2,3]Ordered collectionObject{nama:"JPX"}Key-value structure

Example:

global [x = 10];
global [pi = 3.14];
global [name = "JPX"];
global [active = true];

3. Variables

Variables in JPX are declared using global.

Variable Declaration

global [x = 10];
global [name = "Budi"];
global [numbers = [1,2,3]];

Assignment

Variables can be modified later.

x = 20;
numbers[0] = 99;

JPX allows flexible assignments including list and object modification.

4. Operators

JPX supports common programming operators.

Arithmetic Operators

OperatorFunction+addition / string concatenation-subtraction*multiplication/division

Example:

global [a = 10];
global [b = 5];

print a + b;
print a * b;

Comparison Operators

OperatorMeaning==equal!=not equal<less than>greater than<=less or equal>=greater or equal

Example:

if a > b {
    print "a lebih besar";
}

Logical Operators

JPX uses word-based logical operators.

OperatorMeaningandlogical ANDorlogical ORnotlogical NOT

Example:

if umur > 18 and aktif == true {
    print "User valid";
}

5. Strings

Strings in JPX use double quotes.

print "Hello JPX";

String Interpolation

JPX supports variable interpolation using $.

global [nama = "Budi"];

print "Halo $nama";

Output:

Halo Budi

Multi-line Strings

JPX supports triple-quote multi-line strings.

global [text = """
Baris pertama
Baris kedua
Baris ketiga
"""];

This is useful for documentation or long text output.

6. Lists

Lists are ordered collections.

global [angka = [1,2,3,4,5]];

print angka[0];

Modify list values:

angka[1] = 99;

Lists are flexible and can store mixed data types.

global [data = [1,"teks",true]];

7. Objects (Dictionary)

Objects store key-value pairs.

global [user = {
    nama: "Aldrian",
    umur: 25
}];

Access values:

print user["nama"];

Some interpreters may also support dot notation:

print user.nama;

Objects can be expanded dynamically.

user["kota"] = "Jakarta";

8. Control Structures

JPX includes typical programming control flow structures.

If / Else

if kondisi {
    print "True";
} else {
    print "False";
}

Example:

if x > 10 {
    print "besar";
} else {
    print "kecil";
}

Nested conditions are also supported.

While Loop

global [i = 1];

while i <= 5 {
    print i;
    i = i + 1;
}

This loop will print numbers from 1 to 5.

For Loop

JPX supports two styles.

Range Loop

for i = 1 to 10 {
    print i;
}

List Iteration

global [buah = ["apel","mangga","jeruk"]];

for b in buah {
    print b;
}

Loop Control

Two special statements exist.

Get Alzrwr’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

StatementFunctionbreakexit loopcontinueskip iteration

Example:

for i = 1 to 10 {
    if i == 5 {
        break;
    }
    print i;
}

9. Input and Output

Output with print

print "Hello World";
print 42;
print variabel;

Input using Scanner Module

[scanner];

scanner.input "Nama: ";
global [nama = scanner.read()];

Read integer input:

global [umur = scanner.read_int()];

10. Modules

JPX uses square brackets for module imports.

[print];
[color];
[requests];
[time];

After importing, module functions can be used directly.

Example:

[color];
print color.red("Hello");

11. Built-in Constants

JPX includes three special constants.

true
false
null

These represent boolean and null values.

12. Function Calls

JPX supports two calling styles.

Standard style

print("Hello");
result = add(5,3);

JPX style (no parentheses)

print "Hello";
result = add 5,3;

This flexibility allows more scripting-style code.

13. Standard Library Modules

JPX provides several built-in modules.

Print Module

[print];

print "Hello";

Color Module

[color];

print color.red("Merah");
print color.green("Hijau");

Time Module

[time];

print time.now;
time.wait 2;

HTTP Requests

[requests];

global [res = requests.fetch "https://api.example.com"];
print res.status;

Speedreq (Fast HTTP)

[speedreq];

global [res = speedreq.fetch "https://api.example.com"];

Fetch multiple URLs:

global [results = speedreq.fetch_many [url1,url2,url3]];

14. Syntax Rules

JPX follows several syntax rules.

• every statement ends with ;
• blocks use { }
• language is case-sensitive
• whitespace does not affect execution

Example:

print "Hello";

15. Complete Example Program

Below is a small JPX program.

[print];
[color];
[scanner];

print color.cyan("=== BIODATA ===");
scanner.input "Nama: ";
global [nama = scanner.read()];
scanner.input "Umur: ";
global [umur = scanner.read_int()];
if umur >= 17 {
    print color.green("$nama sudah dewasa");
} else {
    print color.yellow("$nama masih anak-anak");
}
print "Terima kasih!";

This program reads user input and prints different output depending on the age.

Final Thoughts

JPX-Lang is designed to be simple, expressive, and flexible.

Its syntax combines elements of scripting languages with a modular system that allows developers to easily extend functionality.

Although still experimental, JPX already provides:

• variables
• lists
• objects
• control flow
• modules
• HTTP requests
• console utilities

Developers interested in exploring JPX can visit:

Official Website
https://jpx-lang.netlify.app/

GitHub Repository
https://github.com/alzzmetth/jpxlang

As the project evolves, JPX-Lang will continue expanding its syntax, libraries, and tooling ecosystem.