Xeno Language v0.1.4

New API Features

Enhanced Security Configuration:

• Dynamic security limits instead of hardcoded constants
• Configurable pin access control
• Runtime validation of security settings

New Security API Methods:

// Configure security limits
setStringLimit(256)           // Max string length
setVariableNameLimit(32)      // Max variable name length  
setExpressionDepth(32)        // Max expression nesting
setLoopDepth(16)              // Max loop nesting
setIfDepth(16)               // Max if-else nesting
setStackSize(256)            // Stack memory size
setAllowedPins({2,3,13})     // Configure allowed pins
addAllowedPin(5)             // Add single pin
removeAllowedPin(13)         // Remove pin access

Minimum / maximum limits

• MIN_STRING_LENGTH = 1, MAX_STRING_LENGTH_LIMIT = 4096
• MIN_VARIABLE_NAME_LENGTH = 1, MAX_VARIABLE_NAME_LENGTH_LIMIT = 256
• MIN_EXPRESSION_DEPTH = 1, MAX_EXPRESSION_DEPTH_LIMIT = 256
• MIN_LOOP_DEPTH = 1, MAX_LOOP_DEPTH_LIMIT = 64
• MIN_IF_DEPTH = 1, MAX_IF_DEPTH_LIMIT = 64
• MIN_STACK_SIZE = 16, MAX_STACK_SIZE_LIMIT = 2048
• MIN_INSTRUCTIONS_LIMIT = 1000, MAX_INSTRUCTIONS_LIMIT = 1000000
• MIN_PIN_NUMBER = 0, MAX_PIN_NUMBER = 255

All setters validate values; out-of-range values are rejected.

Unified Execution API:

// Single method for compile and run
compile_and_run("print 'Hello World'")

Mathematical Functions Enhancement

Improved Function Processing:

• Unified table-driven approach for all math functions
• Consistent argument handling for multi-parameter functions
• Better error messages for function calls

Code Architecture Improvements

Security System Overhaul:

• XenoSecurityConfig class for flexible limits management
• Dynamic stack allocation based on configuration
• Enhanced bytecode verification with configurable bounds

Debugging Infrastructure:

• Separate Debugger class with unified disassembly
• Improved state inspection with type information
• Better error reporting and validation

Performance Optimizations:

• Optimized string comparison with proper lexicographic order
• Improved type conversion and validation
• Enhanced variable lookup performance

Backward Compatibility

⚠️ Important Notes:

• All existing code from v0.1.3 remains compatible
• Security limits are now configurable (previously hardcoded)
• Pin access must be explicitly configured for non-LED pins
• Stack size is now dynamically allocated

Migration Example:

// v0.1.3 - Hardcoded limits
XenoLanguage xeno;

// v0.1.4 - Configurable security
XenoLanguage xeno;
xeno.setStringLimit(512);
xeno.setAllowedPins({2,3,4,5,13,LED_BUILTIN});

IDE Support

Version 0.1.4 is now fully supported in the official Xeno Language IDE.
🔗 IDE Repository: https://github.com/VLPLAY-Games/XenoLanguageIDE

Recommended for All Users

This update significantly improves security, maintainability, and debugging capabilities while maintaining full backward compatibility with existing Xeno Language programs.

Xeno Language v0.1.3

New Features

Mathematical Functions:

• sin(angle) - sine function (angle in radians)
• cos(angle) - cosine function (angle in radians)
• tan(angle) - tangent function (angle in radians)

Examples:

set result sin(angle)
set x cos(60)

Mathematical Constants:

• M_PI = 3.141592653589793 (π)
• M_E = 2.718281828459045 (Euler's number)
• M_TAU = 6.283185307179586 (2π)
• M_SQRT2 = 1.4142135623730951 (√2)
• M_SQRT3 = 1.7320508075688772 (√3)
• P_LIGHT_SPEED = 299792458 (speed of light in m/s)

Examples:

set result M_TAU * M_PI

Code Improvements

• Fixed cpplint style errors throughout the codebase
• Updated header guards format in all files
• Improved code consistency and readability

Availability

Arduino IDE Library Manager

• Now available directly in Arduino IDE
• Go to: Tools → Manage Libraries...
• Search for "Xeno Language"
• Click "Install" for automatic installation

Manual Installation

• Download from GitHub Releases
• In Arduino IDE: Sketch → Include Library → Add .ZIP Library...
• Select the downloaded Xeno-Language-vX.X.X.zip file

Recommended to update

Xeno Language v0.1.2

Added Boolean Data Type Support:

• New TYPE_BOOL data type in xeno_common.h
• New OP_PUSH_BOOL opcode for boolean values
• Boolean literals true and false support

Enhanced Comparison Operations:

• Boolean comparisons work correctly in if conditions

Updated Documentation:

• Added boolean examples to syntax documentation
• Created new bool.ino example file
• Updated documentation

Security & Stability:

• Added boolean validation in security checks
• Ensured backward compatibility with existing programs

Xeno Language v0.1.1

Fixes and Improvements:

• 🔧 Fixed library structure - main files moved to src/ folder for proper Arduino IDE compatibility
• 📦 Fixed ZIP installation - library now correctly detected when installing via "Add .ZIP Library"
• 📚 Updated installation instructions
• 👮 Some security improvements

Technical Changes:

• Updated library.properties with correct path: includes=src/XenoLanguage.h
• Reorganized file structure to match Arduino standards
• Fixed include paths in source files

Installation

• Download the latest library version from Releases section
• In Arduino IDE: Sketch → Include Library → Add .ZIP Library...
• Select the downloaded Xeno-Language-vX.X.X.zip file

Minimal Arduino / ESP32 example

#include <XenoLanguage.h>
XenoLanguage xeno;
void setup() {
  Serial.begin(115200);
  String program = R"(
    print "Hello from Xeno!"
    halt
  )";
  xeno.compile(program);
  xeno.run();
}

Recommended update for all users of previous version for proper library functionality.

Xeno Language v0.1.0

First Release - Compact Interpreted Language for ESP32

Xeno Language is now available! A lightweight, safe interpreted language and virtual machine designed specifically for the ESP32 (Arduino) ecosystem.

🚀 What is Xeno?

Xeno provides a complete compiler → bytecode → VM pipeline with built-in support for:

• Basic programming: variables, arithmetic, strings, conditionals, loops
• Hardware control: GPIO (LED on/off), delays, Serial I/O
• Safety features: bounds checking, stack protection, secure GPIO access

✨ Key Features

• Embeddable: Direct integration into existing C++ ESP32 projects
• Safe Execution: Built-in limits and validation prevent crashes
• File Support: Execute from .xeno files or embedded strings
• Performance: ~22× slower than native C++ (comparable to other MCU interpreters)
• Memory Efficient: ~20KB RAM usage, ~60KB Flash

🎯 Quick Start

Copy the xenoLang folder to the root of your project and start compiling/running Xeno code. The language supports variables, math operations, conditionals, loops, and basic hardware control.

#include "xenoLang/xeno.h"
Xeno xeno;
xeno.compile("print 'Hello Xeno!'"); 
xeno.run();

📋 Language Basics

• Variables: set x 10
• Math: set result (x + 5) * 2
• Conditionals: if x > 5 then ... endif
• Loops: for i = 1 to 10 ... endfor
• Hardware: led 13 on, delay 1000
• I/O: print "text", input var

🛡️ Safety & Limits

• Configurable memory limits
• Restricted GPIO pin access
• Stack overflow protection
• Bounded execution limits
• Division by zero protection

🔧 Technical Details

• Platform: ESP32 (ESP Core 3.2.0+ recommended)
• Language: C++
• License: Apache 2.0
• VM Architecture: Stack-based bytecode interpreter
• Status: Initial release - active development

📚 Resources

• Full Documentation

This initial release lays the foundation for embedded scripting on ESP32. Perfect for education, prototyping, and adding dynamic behavior to your IoT projects!

Developed by VL_PLAY Games