Origin Programming Language · v1.7.27

Origin is a Python/Java-based programming language with a syntax designed to be expressive, English-like, and hardware-first. It enables AI models and developers to produce scalable code with high readability while retaining the full power of the Python ecosystem.

Visit the official documentation: docs-origin.onrender.com

September 2026 re-issue: The v1.7.27 release adopts the modular package layout (lexer, parser, interpreter, classes subpackages) ported from origin-dev, with the bytecode VM as the default backend. It retains v1.7.26's import normalization plus v1.7.24's bytecode VM and interpreter stability and v1.7.23's multi-import and transformer library updates. The bytecode VM migration continues on the origin-dev branch and will ship as v1.8.

What's new in v1.7.27

• Modular package layout: the flat lexer.py, parser.py, interpreter.py, and classes.py modules are now proper subpackages — origin/lexer/, origin/parser/, origin/classes/ (10 AST node groups), and origin/interpreter/ (5 codegen mixins plus hardware helpers). Same language, same behavior, maintainable structure.
• Split parser: the 1000+ line recursive-descent parser is now BaseParser + ExprMixin + StmtMixin + BlockMixin, combined in parser_point.py. All 26 methods preserved in order.
• Split interpreter: the AST-to-Python translator is now BaseInterpreter plus five per-domain codegen mixins (expressions, control flow, functions/OOP, data literals, system/IO), with generated code verified byte-identical to the legacy implementation.
• Bytecode VM by default: origin file.or compiles through bc/to_byte.py and runs on the stack VM (bc/svm.py); origin i file.or uses the AST interpreter. Both backends produce identical output on arithmetic, f-strings, if/else, for, def, and collections.
• Fresh binaries: rebuilt origin.exe and OriginInstallerV1.7.27.zip from the modular stack.

Key Features

• English-Like Syntax: Write code that reads like natural language.
• Built-in Library System: Import .or library files with import calc, including a math library (calc.or) and graph plotting library (graph.or).
• Hardware Primitives: Native, intuitive commands for Raspberry Pi GPIO and ServoKit (PCA9685).
• Strict Typing: Recommended type annotations (let x: int = 10) for predictable state and AI-native safety, with untyped declarations auto-inferred.
• Safe Hardware I/O: Automatic angle clamping (0-180 degrees) for servos to prevent physical damage.
• Formal Module System: Professional namespacing and module support (import math as m, from lib import x).
• Binary Builder: Compile your Origin scripts into standalone, zero-dependency .exe files.
• Modern Logic: Support for Object-Oriented Programming (classes), try/except/else, parallel thread blocks, and robust scope management.

Installation

Standalone (Recommended)

You can now download Origin as a standalone installer for Windows. This is the fastest way to get started.

1. Download: Origin v1.7.27 Stable
2. Install: Run secure_install.ps1 with PowerShell.
3. Usage: Open a new terminal and type origin.

Developer / Source

1. Clone the repository:

   git clone https://github.com/boblio-max/origin.git
   

2. Install Dependencies:

   pip install -r requirements.txt
   

Language Reference

1. Variables & Types

Origin uses let for variables and const for immutable references. Types are recommended; untyped declarations are auto-inferred.

let   x: int    = 10          # Scalar integer
let   name: str = "Origin"    # String literal
let   flag: bool = true       # Boolean (lowercase)
const e: float = 2.71828      # Immutable constant
let   data: none = none       # None literal

Multiple variables can be declared (and typed) in one statement:

let a, b = 1, 2               # Inferred: int, int
let p, q: int, str = 6, "hi"  # Per-name annotations

Built-in constants and math helpers are available without imports:

print pi       # 3.141592653589793
print abs(-7)  # 7

2. Built-in Libraries

Origin includes a standard library system under lib/. Use import to load them:

import calc
import graph

# Math utilities
calc = calc()
print calc.sqrt(25)
print calc.pi

# Graph plotting
graph "My Plot" with {
    X: color(1,0,0) as "Line A",
}

3. Hardware Control

Control hardware directly with the set namespace and native protocol primitives.

# Set Servo 1 to 90 degrees (clamped 0-180)
set servo.angle 1, 90

# Drive BCM Pin 12 HIGH
set pin 12, 1

# Parentheseless I2C, SPI, and UART calls
i2c.read 0x40, 4
spi.write 0x01

4. Data Structures

# Lists
let tools: list = ["Servo", "GPIO", "I2C"]
print tools[0]

# Dictionaries (Access via { })
let config: dict = {"speed": 100, "active": true}
print config{"speed"}

# Tuples
let coord: tuple = (10, 20)

5. Raw Python Blocks

Seamlessly bridge the gap between Origin and Python.

py {
    import math
    import os
    print("Python process ID:", os.getpid())
    print("Sine of 90 degrees:", math.sin(math.pi/2))
}

6. Module System

Origin supports a formal module system for clean namespacing.

import math_utils as mu        # Import with alias
from robotics import drive     # Selective import

print mu.square(10)
drive(1.0)

7. Object-Oriented Programming

Define classes with fields and methods natively for structured development.

class Sensor (pin type) {
    def read() {
        return pin
    }
}

Origin scripts use the .or extension.

Running a script:

origin main.or

Building a standalone binary:

origin build main.or

Roadmap

The following features are currently in development:

• Pattern Matching: match and case constructs.
• Advanced Structures: struct and enum types.
• Asynchronous I/O: Native async and await support.
• Metaprogramming: macro and inline definitions.
• Unified IDE: A dedicated cross-platform IDE for Origin development.

License & Contact

Distributed under the MIT License. Author: Nikhil Mahankali Contact: nikhilmahankali56@gmail.com