Abhinu.Dev Basic ICTL

A basic programming language made for making the learning journey easy! Contributions are welcome!

Python (for building the language interpreter) | IndianCoder3 | Command Reference | Build Story | Web Editor

Caution

This programming language is still in development. Some features (such as Math.Eval()) used Python's eval() in older versions, which could execute arbitrary code.

⚠️ This applies only to ICTL v1.0 and below. Starting from v1.1.0, Math.Eval() uses a custom math parser instead of eval().

About

Abhinu.Dev Basic ICTL is a beginner-friendly programming language designed to make the learning journey easy and enjoyable. Whether you're just starting out or teaching others to code, ICTL provides a clean, intuitive syntax that focuses on core programming concepts like variables, loops, conditionals, and basic mathematics.

The language is built on Python and runs as an interpreter, making it easy to execute .ictl files directly or use the interactive shell for learning.

Why ICTL?

Simple Syntax: Clear, readable code that's easy to understand
Beginner-Friendly: Designed specifically for learning programming fundamentals
Quick Feedback: Run code immediately via CLI or interactive mode
Educational: Perfect for teaching programming concepts
Active Development: Regular updates and improvements
Community: Contributions and feedback are welcome!

Features

✨ Core Language Features:

Variables: Simple variable declaration and assignment
Data Types: Strings, integers, floats, and booleans
Terminal I/O: Easy input/output operations with styling options
Mathematics: Arithmetic evaluation and numeric comparisons
Control Flow: If/else conditionals with boolean logic
Loops: Counted loops and infinite loops with break/continue support
String Operations: Concatenation and variable interpolation
Error Handling: Clear error messages with line numbers and suggestions

🛠️ Developer Tools:

Interactive Shell: Drop into shell mode for immediate code execution
File Execution: Run .ictl script files from command line
Syntax Highlighting: VS Code extension with full language support
Code Snippets: Quick insertion of common patterns
Comprehensive Documentation: Command reference and examples

Quick Start

1. Create a Simple Program

Create a file named hello.ictl:

Program.Main {
    Terminal.Echo("Hello, World!")
}

2. Run It

If you installed from Release (Easiest):

ictl hello.ictl
# or if using standalone
ICTL-v1.0s.exe hello.ictl

If you're developing from source:

python main.py hello.ictl

3. Output

Hello, World!

Try Interactive Mode

# From release
ictl

# Or from source
python main.py

This drops you into an interactive shell where you can execute ICTL commands line by line.

Web Editor

I also made a web editor interface for testing out ICTL without installing it! Simply visit this link. If the link does not work, try https://basic-ictl-web-studio.onrender.com/

I recommend using the web interface to avoid installation, as there are updates often.

It is based upen Monace, letting me build a autocomplete and syntax hilighting system, and also a ribbon, and a status bar at the bottom.

Installation

Choose one of the two installation paths below, if you want to install it:

🚀 Path 1: Recommended - Use Pre-built Release

The easiest way to get started! Each release includes:

Nuitka/PyInstaller Standalone - Portable executable, no Python required
Inno Setup Installer - System-wide installation for Windows
VSIX Extension - VS Code language support (alongside the main interpreter, of course!)

Download from Releases

Go to GitHub Releases
Download the latest release files for your platform

Option A: Standalone Executable (Easiest - because of constant updates)

# Download ICTL.exe (or your version)
ICTL.exe your_program.ictl

No Python installation required!

Option B: System-wide Installation (Windows)

Download the Inno Setup installer (e.g., ICTL-v1.0s-installer.exe)
Run the installer and follow the prompts
Add ICTL to your system PATH during installation (will be added automatically, cross check)
Use ictl from any command prompt:

ictl your_program.ictl

Option C: Install VS Code Extension

Download the .vsix file from the release
In VS Code, press Ctrl+Shift+P and run Extensions: Install from VSIX...
Select the downloaded VSIX file

💻 Path 2: Development - From Source Code

For developers who want to modify or contribute to the language.

Prerequisites

Python 3.7 or higher
pip (Python package installer)
Nuitka installed (PyInstaller can be used too, but it's slow)
Windows, macOS, or Linux

Installation Steps

Clone the Repository

git clone https://github.com/indiancoder3/abhinu-dev_basic-ictl.git
cd abhinu-dev_basic-ictl

Navigate to ICTL Directory

cd code

Run Programs

# Execute a file
python main.py your_program.ictl

# Or use interactive mode
python main.py

Install VS Code Extension (optional)

See VS Code Extension section for setup instructions.

Language Basics

Variables

Variables store data that you can use throughout your program.

Declaring a Variable:

Variables.New("MyVariable")  # Make sure, quotes here, and no spaces!

Some parts of the documentation have missed quotes, so please understand there should be quotes. Although due to a bug, it works even without quotes, it will be patched in a future update.

Assigning a Value:

Variables.MyVariable = "Hello"
Variables.Counter = 42
Variables.Pi = 3.14

Using Variables:

Program.Main {
    Variables.New("Name")
    Variables.Name = "Alice"
    Terminal.Echo("Hello, " + Variables.Name)
}

String Operations

Strings are enclosed in double quotes and can be concatenated with +:

Program.Main {
    Variables.New(FirstName)
    Variables.New(LastName)
    
    Variables.FirstName = "John"
    Variables.LastName = "Doe"
    
    Terminal.Echo(Variables.FirstName + " " + Variables.LastName)
}

For those who are thinking that using + directly can add too, try 2+2 directly. It will return 22, as Math is suppposed to be evaluated via Math.Eval

Terminal I/O

Output (Echo):

Terminal.Echo("This is printed to the screen")
Terminal.Echo(Variables.Counter)

Input (Ask):

Program.Main {
    Variables.New("Name")
    Variables.Name = Terminal.Ask("What is your name? ")
    Terminal.Echo("Nice to meet you, " + Variables.Name)
}

Styling Output:

Terminal.Style("green")
Terminal.Echo("This text is green!")
Terminal.Style("red")
Terminal.Echo("This text is red!")
Terminal.Style("reset")

Available styles: red, green, blue, yellow, cyan, magenta, bold, reset

Mathematics

Evaluating Expressions:

Program.Main {
    Variables.New("Result")
    Variables.Result = Math.Eval(10 + 5)
    Terminal.Echo(Variables.Result)  # Output: 15
    
    Variables.Result = Math.Eval((2 + 3) * 4)
    Terminal.Echo(Variables.Result)  # Output: 20
    
    Variables.Result = Math.Eval(100 / 4)
    Terminal.Echo(Variables.Result)  # Output: 25.0
}

Supported operators: +, -, *, /, parentheses ()

Comparing Numbers:

Program.Main {
    Variables.New("X")
    Variables.X = 10
    
    Program.If(Math.Compare(Variables.X, ">", 5)) {
        Terminal.Echo("X is greater than 5")
    }
}

Operators: >, <, >=, <=, ==, !=

Conditionals

If Statement with Else:

Program.Main {
    Variables.New("Age")
    Variables.Age = Terminal.Ask("How old are you? ")
    
    Program.If(Math.Compare(Variables.Age, ">=", 18)) {
        Terminal.Echo("You are an adult")
    }
    Program.Else {
        Terminal.Echo("You are a kid!")
    }
}

Nested Conditionals:

Program.If(Math.Compare(Variables.Score, ">", 90)) {
    Terminal.Echo("Grade: A")
    
    Program.If(Math.Compare(Variables.Score, "==", 100)) {
        Terminal.Echo("Perfect score!")
    }
}
Program.Else {
    Program.If(Math.Compare(Variables.Score, ">", 80)) {
        Terminal.Echo("Grade: B, you were left out just by a few marks!")
    }
}

Loops

Counted Loop:

Program.Main {
    Program.Loop(5) {
        Terminal.Echo("This runs 5 times")
    }
}

Infinite Loop with Break:

Program.Main {
    Variables.New(Counter)
    Variables.Counter = 0
    
    Program.ForeverLoop {
        Variables.Counter = Math.Eval(Variables.Counter + 1)
        Terminal.Echo("Count: " + Variables.Counter)
        
        Program.If(Math.Compare(Variables.Counter, ">=", 10)) {
            Program.BreakLoop
        }
    }
}

Continue Statement:

Program.Loop(10) {
    Program.If(Math.Compare(Variables.i, "==", 5)) {
        Program.Continue
    }
    Terminal.Echo(Variables.i)
}

Additional improvement for the examples is needed, contributions here are welcome!

Command Reference

Terminal Commands

Command	Description	Example
`Terminal.Echo(<expr>)`	Print to console	`Terminal.Echo("Hello")`
`Terminal.Ask(<prompt>)`	Get user input	`Variables.X = Terminal.Ask("Enter value: ")`
`Terminal.Style(<style>)`	Set text color/style	`Terminal.Style("green")`
`Terminal.Clear`	Clear the terminal	`Terminal.Clear`

Variable Commands

Command	Description	Example
`Variables.New(<name>)`	Declare variable	`Variables.New(MyVar)`
`Variables.<name> = <expr>`	Assign value	`Variables.MyVar = 42`
`Variables.<name>`	Read variable	`Terminal.Echo(Variables.MyVar)`

Math Commands

Command	Description	Example
`Math.Eval(<expr>)`	Calculate expression	`Math.Eval(10 + 5 * 2)`
`Math.Compare(<a>, <op>, <b>)`	Compare numbers	`Math.Compare(X, ">", 5)`
`Data.Compare(<a>, <b>)`	Compare values (as strings)	`Data.Compare(Input, "yes")`
`Math.Random(<min>, <max>)`	Output a random number in the range	`Math.Random(1, 100)`

Control Flow

Command	Description	Example
`Program.Main { ... }`	Program entry point	`Program.Main { ... }`
`Program.If(<cond>) { ... }`	Conditional execution	`Program.If(cond) { ... }`
`Program.Else { ... }`	Else for the If	`Program.Else { ... }`
`Program.Loop(<n>) { ... }`	Loop N times	`Program.Loop(10) { ... }`
`Program.ForeverLoop { ... }`	Infinite loop	`Program.ForeverLoop { ... }`
`Program.BreakLoop`	Exit loop	`Program.BreakLoop`
`Program.Continue`	Next iteration	`Program.Continue`
`Program.Not(<cond>)`	Flip a condition	`Program.Not(Data.Compare("h", "h"))`

Time Commands

Command	Description	Example
`Time.Wait(<duration in sec>)`	Wait for seconds	`Time.Wait(2.5)`
`Time.Current(<format>)`	Fetch current time in a format	`Variables.Time = Time.Current("hh:mm tt")`

VS Code Extension

The ICTL language is supported in VS Code with syntax highlighting, code snippets, and language configuration.

Installation

Open Abhinu.Dev Basic ICTL Language Support in your browser.
Press Install, it will ask if you do have VS Code. Continue, and let the website open VS Code.
You will see the extension. Install it.

Or:

Download the extension VSIX file the latest release.
In VS Code, press Ctrl+Shift+P and run Extensions: Install from VSIX...
Select the downloaded VSIX file.

Features

🎨 Syntax Highlighting: Full highlighting for all ICTL constructs
📝 Learning Focused: Catergorised properly, helping code and learn easily
⚙️ Language Configuration: Auto-closing brackets, comments, indentation

Usage

Once installed, VS Code automatically recognizes .ictl files with full language support.

Create a new file example.ictl:

Program.Main {
    Terminal.Echo("Hello from VS Code!")
}

Examples

The repository includes several complete examples in ictl/examples/:

basic_test.ictl - Basic variables and math
basic-math_test.ictl - Math operations
if-loops_test.ictl - Conditionals and loops
welcome_test.ictl - Interactive tutorial
megatest.ictl - Comprehensive test

Running Examples

ictl examples/basic_test.ictl
ictl examples/welcome_test.ictl

Building from Source

Requirements

Python 3.7+
pip (Python package installer)

Setup

# Clone the repository
git clone https://github.com/indiancoder3/abhinu-dev_basic-ictl.git
cd abhinu-dev_basic-ictl

# Navigate to ICTL directory
cd code

# Run the interpreter
python main.py           # Interactive mode
python main.py test.ictl # Execute a file

Contributing

Contributions are welcome! Whether it's bug fixes, new features, examples, or documentation improvements, please feel free to contribute.

How to Contribute

Fork the repository
Create a feature branch: git checkout -b feature/your-feature
Make your changes
Test thoroughly
Commit with clear messages: git commit -am 'Add new feature'
Push to the branch: git push origin feature/your-feature
Submit a Pull Request

Areas We Need Help With

More example programs
Documentation improvements
Bug fixes and testing
Feature suggestions and discussions
VS Code extension enhancements
Expansion of the language

Troubleshooting

Common Issues

FileNotFoundError: File not found

Ensure the .ictl file exists and the path is correct
Use absolute path or run from the correct directory

Syntax Error

Check that Program.Main { ... } wraps all code (not mandatory, but recommended since v1.1.0, older versions require it)
Verify variable names don't have spaces
Ensure proper bracket matching

Variable not defined

Declare variables with Variables.New(Name) before use
Check spelling and capitalization

Invalid expression (and includes the variable name) in Math

This bug only happens when you didn't make a variable, or you did make it, but never assigned a value.

Building Story

I started off with Scratch and then explored Python and HTML. I noticed that switching from Scratch to Python is easy for some things, but there’s no simple graphics built-in (unless you use PyGame or Turtle).

So, I wanted a language that’s easy to understand for beginners. That’s how Abhinu.Dev Basic ICTL was born!

The Name Lore

Abhinu.Dev: My name is Abhinu, so the project is called Abhinu.Dev.
ICTL: My handle is @IndianCoder3 → IC3 → ICT → ICTL.

The Goals of the Language

Currently, there is no GUI or something, but I am trying to implement it! So, Any help or contributions are welcome! We need graphics for this. Right now, I can think of the Small Basic Turtle, but let's see...

License

This project is licensed under the GNU GPL v3 — a copyleft open-source license. Orignally, it was licensed under MIT.

For Package Users

If you use ICTL in your project, simply include:

This project uses Abhinu.Dev Basic ICTL, licensed under the GNU GPL v3 License.
Copyright (c) 2026 IndianCoder3

For full license details, visit: https://www.gnu.org/licenses/

Credits

Special thanks to:

The Python community
All contributors and feedback providers
The open-source community

Contact & Support

For questions, issues, or suggestions:

GitHub: @indiancoder3
GitHub Issues: Report bugs and request features
Email: indiancoder3@hotmail.com

Happy Coding! 🚀

Name		Name	Last commit message	Last commit date
Latest commit History 22 Commits
ICTL-StudioOnline_Release		ICTL-StudioOnline_Release
code		code
logo-graphics		logo-graphics
publish		publish
.gitattributes		.gitattributes
.gitignore		.gitignore
CONTRIBUTING.md		CONTRIBUTING.md
HISTORY.md		HISTORY.md
LANGUAGE_REFERENCE.md		LANGUAGE_REFERENCE.md
LICENSE		LICENSE
editor.html		editor.html
ictl_banner.png		ictl_banner.png
readme.md		readme.md

Folders and files

Latest commit

History

Repository files navigation

Abhinu.Dev Basic ICTL

Table of Contents

About

Why ICTL?

Features

Quick Start

1. Create a Simple Program

2. Run It

3. Output

Try Interactive Mode

Web Editor

Installation

🚀 Path 1: Recommended - Use Pre-built Release

Download from Releases

Option A: Standalone Executable (Easiest - because of constant updates)

Option B: System-wide Installation (Windows)

Option C: Install VS Code Extension

💻 Path 2: Development - From Source Code

Prerequisites

Installation Steps

Language Basics

Variables

String Operations

Terminal I/O

Mathematics

Conditionals

Loops

Command Reference

Terminal Commands

Variable Commands

Math Commands

Control Flow

Time Commands

VS Code Extension

Installation

Features

Usage

Examples

Running Examples

Building from Source

Requirements

Setup

Contributing

How to Contribute

Areas We Need Help With

Troubleshooting

Common Issues

Building Story

The Name Lore

The Goals of the Language

License

For Package Users

Credits

Contact & Support

About

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Releases 2

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages