Latest Stable Release Available →

TechScript Write like a Human. Run like Rust.

The plain-English programming language. Zero symbols. Zero overhead. TechScript replaces cryptic syntax clutter with clear keyword grammar, compiling into bytecode executed on a high-speed stack VM written in Rust or native machine code via an LLVM backend.

🦀 Custom Rust Stack VM
⚡ LLVM Native Backend
📦 Single Toolchain (tsc)
🤖 Native AI (use ai)
🛡️ Zero Syntax Clutter
Download Latest Documentation Portal Interactive Examples GitHub Repository
Latest Version Fetching...
Build Status Passing
GitHub Stars ...
Open Issues ...
License MIT
Platforms Win • Linux • macOS • Termux

// language capabilities

TechScript Language Features: Designed for Humans, Built for Speed

Experience the power of modern compiler engineering combined with plain-English, human-readable grammar. TechScript is a programming language built in Rust, powered by LLVM, with a complete standard library for AI, SQLite, Canvas, HTTP, and more.

🐉

Zero Syntax Clutter

Replace curly braces, semicolons, and cryptic operator symbols with clean keywords like do, end, when, else, say, and send.

Syntax Engine
🦀

Custom Rust Stack VM

Powered by a high-performance stack-based Virtual Machine written in Rust. Utilizes NaN-boxed value representations and an integrated tracing Garbage Collector.

Virtual Machine
⚡

Native LLVM Backend

Compile TechScript programs into optimized native machine code executables for maximum hardware speed via the dedicated LLVM crate generator.

Native Compiler
🛠️

Unified Compiler Driver

Single toolchain driver executable tsc handles running, building, testing, linting, formatting, package publishing, and AST dumping.

Toolchain CLI
🤖

Native AI Integration

Built-in ai standard library module provides seamless Gemini model prompting and text generation directly inside scripts.

Stdlib AI
📚

11 Core Stdlib Modules

Batteries included out of the box: math, collections, file, json, http, sqlite, canvas, time, thread, ai, and testing.

Standard Library
🎨

VS Code & LSP Support

Full Language Server Protocol support (techscript-lsp) with official VS Code extensions available on Visual Studio Marketplace and Open VSX.

IDE Ecosystem
🌐

Cross-Platform Runtime

Runs anywhere. Download ready-to-run installers for Windows, Linux, macOS, Android (Termux), or PyPI python package (pip install techscript).

Universal Support

// live editor & interactive execution

Interactive TechScript Playground

Select code examples below to view syntax, modify code, and execute simulated VM bytecode outputs live in your browser.

hello.txs
Simulated Terminal Stdout Exit Code: 0 

              

            

          

        

      

    


    
    

      

        

          
// side-by-side readability

          
Compare Readability

          
See how TechScript syntax eliminates punctuation clutter compared with Python and JavaScript.

        


        

          

            
              

                Feature
                🐉 TechScript
                🐍 Python
                🌐 JavaScript
              

            
            
              

                Variable
                x = 10
                x = 10
                let x = 10;
              

              

                Constant
                const PI = 3.14159
                PI = 3.14159 # convention
                const PI = 3.14159;
              

              

                Function
                do greet(name)
  send "Hi " + name
end		
                def greet(name):
  return "Hi " + name		
                function greet(name) {
  return "Hi " + name;
}		
              

              

                Condition
                when x > 5
  say "Big"
else
  say "Small"
end		
                if x > 5:
  print("Big")
else:
  print("Small")		
                if (x > 5) {
  console.log("Big");
} else {
  console.log("Small");
}		
              

              

                For Loop
                for item in list
  say item
end		
                for item in list:
  print(item)		
                for (let item of list) {
  console.log(item);
}		
              

              

                Try / Catch
                try
  res = divide(10, 0)
catch error
  say error
end		
                try:
  res = divide(10, 0)
except Exception as error:
  print(error)		
                try {
  let res = divide(10, 0);
} catch (error) {
  console.error(error);
}		
              

            
          

        


        

          

            
🐉 TechScript

            
# Fibonacci recursion in TechScript
do fib(n)
  when n <= 1
    send n
  end
  send fib(n - 1) + fib(n - 2)
end

say fib(10) # 55

          


          

            
🐍 Python

            
# Fibonacci recursion in Python
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(10)) # 55

          


          

            
🌐 JavaScript

            
// Fibonacci recursion in JavaScript
function fib(n) {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
}

console.log(fib(10)); // 55

          

        

      

    


    
    

      

        

          
// architecture pipeline

          
Under the Hood: tsc Pipeline

          
The TechScript compiler driver transforms source code into optimized VM bytecode or native machine code binaries.

        


        

          

            
1

            
Source Code

            





						See More
					
.txs plain English script file.

          

          

          

            
2

            
Lexer & Pratt Parser

            
Logos tokenizing & Pratt expression AST construction.

          

          

          

            
3

            
Semantic Audit & Optimizer

            
Lexical scope validation & compile-time constant folding.

          

          

          

            
4

            
IR Crate Generation

            
Produces Intermediate Representation for execution targets.

          

          

          

            
5

            
Execution Targets

            
VM Target: Bytecode VM with tracing GC.
Native Target: LLVM binary emit.

          

        

      

    


    
    

      

        

          
// installation center

          
Download & Install TechScript — Windows, Linux, macOS, Android

          
Download the TechScript compiler and tsc CLI driver. Native installers for Windows, automated shell scripts for Linux & macOS, Termux support for Android, and a PyPI package for cross-platform installation via pip.

        


        
        

          

            Latest Release
            Fetching...
            ...
          

          

            
              View Release Notes on GitHub ↗
            
          

        


        

          
          

            ⭐ Recommended for Windows
            
🪟 Windows Setup

            
Official installer configures PATH, environment associations for .txs files, and installs the tsc toolchain.

            

              →
              TechScript_Setup.exe
              ⬇ Download
            

            

              Download Zero-Install Portable ZIP
            

            

              
✓Native tsc compiler driver & stack VM

              
✓Automatic System PATH configuration

              
✓VS Code extension integration

            

          


          
          

            🐧 Linux / 🍎 macOS
            
Linux & macOS Setup

            
Auto-detects OS and processor architecture to fetch the native compiler binary instantly via curl.

            

              $
              curl -fsSL https://raw.githubusercontent.com/Tcode-Motion/techscript/main/scripts/install.sh | bash
              
            

            

              
✓Single-command automated installation

              
✓ARM64 and x86_64 pre-built binaries

              
✓Executes inside bash / zsh terminals

            

          


          
          

            🤖 Android (Termux)
            
Android Termux

            
Run TechScript directly on your mobile device inside Termux environment.

            

              $
              pkg update && pkg install curl && curl -fsSL https://raw.githubusercontent.com/Tcode-Motion/techscript/main/scripts/install.sh | bash
              
            

            

              
✓Full mobile CLI execution support

            

          


          
          

            🐍 Python (pip)
            
PyPI Package Index

            
Cross-platform wrapper package that downloads binary toolchain automatically.

            

              $
              pip install techscript
              
            

            

              
✓Installs techscript & tsc CLI aliases

            

          


          
          

            🍺 Homebrew / Winget / Scoop
            
Package Managers

            
Official Homebrew bottle, Winget manifest, and Scoop bucket support.

            

              $
              brew install techscript
              Coming Soon
            

            

              
✓Managed automated software updates

            

          


          
          

            📦 Source Code
            
Source Archives

            
Build directly from Rust sources or download release source tarballs.

            

              $
              git clone https://github.com/Tcode-Motion/techscript.git && cargo build --release
            

            

              Source ZIP
              •
              Source TAR.GZ
            

          

        

      

    


    
    

      

        

          
// documentation portal

          
TechScript Official Documentation & Language Reference

          
Browse complete TechScript documentation: getting started guide, syntax reference, CLI commands (tsc), standard library API, compiler architecture, performance benchmarks, examples, and release notes. The official TechScript docs portal.

        


        

          
          

          
          

            
          

        

      

    


    
    

      

        

          
// project development milestones

          
TechScript Development Roadmap & Release Milestones

          
Track completed achievements and upcoming milestones for the TechScript programming language, compiler, LLVM backend, package manager (tspm), and LSP extension.

        


        

          

            

              
Phase 1: Compiler & Toolchain Foundation

              ✓ Completed
            

            
    
              
  • Pratt Expression Parser — Full precedence-based expression parsing.
    • 
              
  • Async & Await Event Loop — Built-in non-blocking concurrency model.
    • 
              
  • Bundled Toolchain CLI (tsc) — Integrated fmt, lint, test, repl, and check commands.
    • 
            

          


          

            
            

              
Phase 2: LLVM Native Backend & Package Registry

              ⚡ In Progress
            

            
    
              
  • LLVM Code Generator — Compile .txs to standalone machine binaries.
    • 
              
  • Package Manager (tspm) — Submit and download ecosystem libraries.
    • 
              
  • LSP Extensions — Diagnostics, hover signatures, and completion engine.
    • 
            

          


          

            

              
Phase 3: Formal Verification & Profiler Tools

              🚀 Planned
            

            
    
              
  • Memory Profiler & Debugger — Interactive stepping inside stack VM execution.
    • 
              
  • Formally Verified Core Libraries — Mathematical correctness proofs for standard functions.
    • 
              
  • JIT Compilation Layer — Dynamic bytecode JIT compiler for hot execution loops.
    • 
            

          

        

      

    


    
    

      

        

          
// version changelog

          
TechScript Release Notes & Version Changelog

          
TechScript release notes and version changelog — automatically synchronized from the GitHub Releases API. View the full release history on the TechScript GitHub Releases page.

        


        

          
Loading latest releases from GitHub API...

        

      

    


    
    

      

        

          
// inquiries

          
TechScript FAQ — Frequently Asked Questions

          
Everything you need to know about TechScript: installation, the tsc compiler driver, LLVM backend, VS Code extension, MIT license, supported platforms, and how to get started with the TechScript programming language.

        


        

          

            
            
          


          

            
            
          


          

            
            
          


          

            
            
          


          

            
            
          

        

      

    


    
    

      

        

          
// community & ecosystem

          
TechScript Open Source Community & Ecosystem

          
Join the TechScript open source community on Discord and GitHub. Contribute to the TechScript compiler, standard library, VS Code extension, or ecosystem tooling. MIT licensed. All contributions welcome.

        


        

          
            🐙
            
GitHub Repository

            
Explore source code, build targets, and submit pull requests.

            View Repo ↗
          

          
            💡
            
GitHub Discussions

            
Propose language features, ask questions, and share project ideas.

            Join Discussion ↗
          

          
            💬
            
Discord Community

            
Chat directly with contributors and fellow TechScript developers.

            Join Discord ↗
          

          
            🎨
            
VS Code Extension

            
Official language support extension on VS Code Marketplace & Open VSX.

            Install Extension ↗
          
        


        
        

          
Project Contributors

          
Special thanks to everyone contributing to the compiler, docs, and ecosystem tools.

          

            
Loading contributors...

          

        


        
        

          
First Steps to Contribute

          

            

              
              

                
Fork the Repository

                gh repo fork Tcode-Motion/techscript
              

            

            

              
              

                
Build and Run Tests

                cargo build && cargo test
              

            

            

              
              

                
Run Examples with tsc

                cargo run --bin tsc -- run examples/hello_world/hello.txs
              

            

          

        

      

    


  


  
  
    

      

        
        
        ESC