Quantix Documentation

Quantix is a friendly, beginner-first scripting language with clean English-like syntax, case-insensitive commands and instant feedback. It runs on Node.js and Bun with zero dependencies, and a full-featured playground lives right in the browser.

What makes Quantix different?

Installation

Quantix has zero runtime dependencies. You need only Node.js 20+ or Bun. To enjoy the optional native desktop GUI and Kachua windows, install PyQt5 (or PySide6) as well — everything gracefully falls back to web rendering without it.

Option 1 — Run online (zero install)

Open the Playground. The entire language runs inside your browser tab on a Cloudflare Worker. Nothing to download.

Option 2 — From the GitHub repo

git clone https://github.com/Sanskriti-Studios/Quantix.git
cd Quantix
node bin/quantix                # interactive shell
node bin/quantix examples/demo.qtx   # run a program file

Option 3 — Via npm

npm install -g quantix-js
quantix help

Optional: native GUI & turtle (desktop)

The desktop interpreter can open real desktop windows for GUI dialogs and the Kachua turtle. This requires Python 3 with Qt:

pip install PyQt5        # recommended (use PySide6 as an alternative)
# or, if you prefer the classic turtle module:
sudo apt install python3-tk   # Debian/Ubuntu

When Python/Qt isn't available, Quantix silently renders GUI and turtle output as HTML/SVG in your browser instead. You can force the web renderer with the environment variable QX_DISABLE_NATIVE=1.

Your first program

Create a file called hello.qtx:

Program.Main {
    Variables.Name = Terminal.Ask("What's your name? ")
    Terminal.Echo("")
    Terminal.Echo("Hello, " + Variables.Name + "! Welcome to Quantix.")
    Terminal.Style("green")
    Terminal.Echo("You just wrote your first line of code.")
    Terminal.Style("reset")
}

Run it:

node bin/quantix hello.qtx

A slightly bigger example

Program.Main {
    # Roll a dice and make a decision
    Variables.Dice = Math.Random(1, 6)
    Terminal.Echo("You rolled a " + Variables.Dice)

    Program.If(Math.Compare(Variables.Dice, ">=", 4)) {
        Terminal.Echo("Nice roll! You win.")
    }
    Program.Else {
        Terminal.Echo("Better luck next time.")
    }

    # Loop with a Kachua square, five times
    Variables.I = 1
    Program.Loop(4) {
        Kachua.Forward(80)
        Kachua.Right(90)
    }
    Kachua.Show()
}

Language fundamentals

Comments

Anything after # is ignored until the end of the line.

Program.Main {
    # This line does nothing at runtime
    Terminal.Echo("Hi")  # inline comments work too
}

Blocks

Quantix is block-structured. Program.Main, conditionals, loops and Kheers all open with { and close with }. Blocks can be nested at any depth.

Case insensitivity

Commands, keywords and variable lookups are all case-insensitive:

Program.Main {
    terminal.echo("lowercase works")
    TERMINAL.ECHO("UPPERCASE works too")
    Variables.X = 5
    Terminal.Echo(variables.x)   # identical to Variables.X
}

Kheers — your own procedures

A Kheer is a reusable procedure. Define one with Program.Kheer(Name) { ... } and run it with Program.ExecuteKheer(Name). Button handlers in GUI.Window also fire Kheers.

Program.Main {
    Program.Kheer(Greet) {
        Terminal.Echo("Greetings from my custom Kheer!")
    }
    Program.ExecuteKheer(Greet)
    Program.ExecuteKheer(Greet)
}

Good to know

• Booleans are written True and False.
• Built-in variables (Variables.X) hold numbers, text, booleans and lists.
• Everything is synchronous — programs execute top to bottom like a recipe.
• Use Math.Eval(...) to compute arithmetic inside expressions.

How the interpreter works

Quantix is a small, dependency-free interpreter written in modern JavaScript. Understanding its pipeline helps you contribute and debug.

Project layout

bin/quantix               # executable entry point
src/main.js               # CLI entry (shell or file mode)
src/shell.js              # interactive REPL
src/runtime.js            # evaluator, expression engine, block execution
src/parser.js             # block parser
src/error_handler.js      # QuantixError family
src/handlers/             # per-category command handlers
src/builtins/             # terminal, time, gui, turtle_graphics, stringify
src/native/               # Python/Qt bridge (real desktop windows)
cloudflare/               # web playground worker (runs Quantix in the browser)
tests/                    # Node test suite (Node & Bun)

The Cloudflare copy in cloudflare/src/interp/ is a browser-safe build that replaces desktop sinks (files, processes) with WebSocket and in-tab output — the desktop interpreter in src/ stays the canonical one.

Values, types & variables

Quantix values are plain: numbers, text, booleans (True/False) and lists. Everything is visible to the same case-insensitive variable store.

Program.Main {
    Variables.Name = "Abhinu"        # text
    Variables.Age = 25               # number
    Variables.Ok = True              # boolean
    Variables.Scores = [10, 20, 30]  # list

    Terminal.Echo("Type of Name is " + Data.TypeOf(Variables.Name))
    Terminal.Echo("Type of Age is " + Data.TypeOf(Variables.Age))
}

Check the Data reference for comparison and conversion commands, and Lists for working with collections.

Reference — Terminal

Note: Terminal.Style and Terminal.Clear are handled by the shell/CLI; the core evaluator dispatches Echo and Ask through the terminal builtin.

Reference — Lists

Reference — Math

Inside expressions you can also use sqrt(x), the power operator ^, parentheses and the usual + - * /.

Reference — Data

Reference — Time

Format tokens

YYYY YY MM M DD D HH (24h) hh (12h) mm m ss s tt (AM/PM).

Reference — Program & Kheers

Reference — GUI

GUI commands open real desktop windows when the native backend is available; otherwise they render as browser pages. Every command is case-insensitive.

Window example

Program.Main {
    GUI.Window("My App", 420, 260)
    GUI.Label("What is your name?")
    Variables.Id = GUI.TextField("Type here...", "")
    GUI.Button("Say hello", Greet)
    GUI.ShowWindow()
 
    Kheer: Greet
    Program.Kheer(Greet) {
        Variables.Name = GUI.GetTextField(Variables.Id)
        GUI.MessageBox("Hi", "Hello, " + Variables.Name + "!")
    }
    # Note: Kheers used by buttons may be defined anywhere in the block.
}

Reference — Kachua (turtle graphics)

Kachua — kachuā means turtle — is Quantix's Logo-style graphics turtle. On the desktop it draws into a real Qt window; on the web it renders an SVG.

Debug harness

The repo ships a ready-made test drawing in examples/kachua_test.qtx that draws a square — run it with node bin/quantix examples/kachua_test.qtx.

Reference — Interactive shell commands

Type these inside node bin/quantix with no file:

Error handling

Quantix wraps runtime failures in a typed error family so problems are always identified clearly:

In the interactive shell, the offending line is printed with a marker (─ ─ ►) pointing at the problem, and the interpreter safely continues to the next command.

Native desktop GUI & turtle

Quantix's original Python edition used real windows. The JavaScript port restores that on desktop through a small native bridge:

• Python backend (src/native/quantix_native.py) picks PyQt5, then PySide6, then falls back to tkinter. Kachua uses a real Qt graphics view (or the stdlib turtle) and opens an actual window.
• JS client (src/native/bridge.js) talks to it over a tiny file protocol, so the interpreter stays fully synchronous.
• When Python/Qt or a display is unavailable, GUI and Kachua render as HTML dialogs / SVG drawings instead — the same code path the web playground uses.

# Use native windows by default (recommended for a real desktop):
node bin/quantix examples/kachua_test.qtx

# Force the web/HTML/SVG renderer:
QX_DISABLE_NATIVE=1 node bin/quantix examples/kachua_test.qtx

The web playground

The Playground is powered by a Cloudflare Worker that embeds Quantix's interpreter and runs your code in your browser via WebSocket. It brings:

• A syntax-highlighted editor with example starter scripts.
• A live output terminal, so Terminal.Echo and Terminal.Ask feel just like the desktop.
• Kachua drawings rendered directly in the page as SVG.
• Automatic saving of your code as you type.

Contributing

Quantix is free software made with passion, and contributions are warmly welcome — code, docs, issues, examples, or just a GitHub star.

Where everything lives

• Handlers for new commands: src/handlers/*.js (register new names in the dispatch map).
• Behaviour behind commands: src/builtins/*.js.
• Native GUI/turtle: src/native/quantix_native.py (PyQt5) and src/native/bridge.js.
• Web playground: cloudflare/ (worker + interp).
• Site/docs: website/.

Workflow

1. Fork Sanskriti-Studios/Quantix and clone your fork.
2. Create a branch, make your change, and keep it dependency-free.
3. Add or update tests in tests/.
4. Run the suite and a syntax pass:

   npm test                # Node test suite
   make check              # syntax-check all sources

5. Push and open a Pull Request. Every check must pass before merge.

License

Quantix is distributed under the terms of the GNU General Public License v3. You are free to use, study, share and modify it, provided derivative works stay under the same license. The full text ships in the repository as LICENSE and is printed by the shell with the license command.