A minimal, high-performance language designed specifically for AI code generation. Achieve 78.1% token reduction while maintaining full expressiveness.
Every operation is designed to minimize token count. Single-character operators and prefix notation eliminate unnecessary tokens.
4.58x more token-efficient than Python. Process more code in the same context window, reducing costs and improving speed.
Designed from the ground up for AI code generation. Predictable syntax, explicit typing, and minimal ambiguity.
Only 5 keywords: fn, let, call, if, loop. Simple to learn, powerful to use.
S-expressions eliminate operator precedence ambiguity. Every operation is clear and unambiguous.
Explicit type prefixes (i, f, s, b) ensure deterministic typing without verbose syntax.
See how NuraScript compares to Python
x = 5
y = 10
result = x + y(let ix 5)
(let iy 10)
(let iresult (+ ix iy))def add(a, b):
return a + b(fn add (ia ib) (+ ia ib))if x > 0:
result = x * 2
else:
result = 0(if (> ix 0)
(let iresult (* ix 2))
(let iresult 0))for i in range(0, 10):
print(i)(loop ii 0 10 (call print ii))def fibonacci(n):
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)(fn fibonacci (in)
(if (< in 2)
in
(+ (call fibonacci (- in 1))
(call fibonacci (- in 2)))))NuraScript's token-efficiency principles extend to English and other languages
The same design principles that make NuraScript 78% more token-efficient for code can be applied to English documentation, comments, and prompts. This enables token-efficient communication with LLMs while maintaining semantic clarity.
Replace verbose phrases with compact tokens. "Make sure to" → [req] (3 tokens → 1)
Use symbols for common concepts. "for each" → @, "error" → !
Organize instructions in compact, unambiguous notation using brackets and prefixes.
These principles can be adapted to any language, not just English, for global token efficiency.
Please write a function that takes two numbers and returns their sum. Make sure to handle edge cases and include error handling.[task:fn] [in:2nums] [out:sum] [req:edge+err]Create a Python class called UserManager that has methods for adding users, removing users, and listing all users. The class should use a dictionary to store user data.[class:UserManager]
[methods:add_user,remove_user,list_users]
[store:dict]Write token-efficient inline documentation that LLMs understand while using minimal tokens.
Documentation that fits more information in the same context window, reducing costs.
Preprocess prompts and instructions to reduce token count by 70%+ while maintaining clarity.
These principles work for any language - adapt the abbreviation dictionary to your language.
FrendlyApp Server API - Production Codebase Analysis
We analyzed a production server codebase with 45 Python files totaling 32,201 tokens. Here's what happened when we converted to NuraScript:
messages.py - 3,495 → 765 tokens (saves 2,730)If this codebase is used in LLM prompts 1,000 times:
i (int), f (float), s (string), b (bool)
fn, let, call, if, loop
+, -, *, /, =, !, <, >
⚡ ALPHA - NuraScript is currently in active development. The language specification is stable, and we're continuously improving the transpiler and runtime.
NuraScript will be open source, making token-efficient AI code generation accessible to everyone.
Features include:
NuraScript is created by Nathan Sloan, a technologist passionate about AI and LLMs, and guiding their impact on technology and society.
This project explores how token-efficient language design can dramatically reduce costs and improve performance when working with large language models, while ensuring responsible and thoughtful AI development.