DocumentationDownloadCommunityContribute
About Astra

Built to be simple to read, serious to use.

Astra is a fast, expressive programming language with one job: reduce the distance between what you mean and what you type. No imports for basic structures, no ceremony before your first line runs.

Less syntax to remember, more problem to solve.

1

Reads like plain instructions

write, repeat, if, then — the keywords describe what they do. There's very little syntax to memorize before you're productive.

2

One way to hold data

Chains replace arrays, structs, classes, and JSON parsing with one consistent pattern, so you learn a single mental model instead of four.

3

Forgiving by default

Division by zero, undefined variables, and type mismatches are catchable, named errors instead of silent crashes.

4

Interactive from the start

The REPL lets you try a line of Astra and see the result immediately, with no compile step to wait through.

easy.astra
\\ No type declarations. No semicolon hunting. \\ No imports for basic structures. name = "Astra" age = 1 if age == 1 write name + " just turned one." ;

Features you won't find bolted together elsewhere.

Most languages borrow these ideas from each other. Astra treats them as the starting point.

⛓️
Chains
Array, struct, OOP, and JSON in a single construct. No separate class syntax, no boilerplate.
🔀
Tri-state boolean
true, false, and maybe — uncertainty is a first-class value, not something you bolt on with null.
♾️
Safe division
Division by zero returns INFINITE instead of crashing your program.
🔗
Variable links
a->b keeps two variables in sync automatically, until one is reassigned directly.
🎯
Modifiers
Wrap any function with before/after behavior — logging, timing, or validation, without touching the original code.
🛡️
Structured errors
when/then catches specific error types by name, so one bad line doesn't take down the whole program.

One developer, one language, built from scratch.

RV

Rajanala Vijay Kumar

Creator of Astra

Astra started as a question: what would a language look like if arrays, structs, objects, and JSON didn't need four different syntaxes to express? That question became chains— Astra's signature feature, and the reason the rest of the language reads the way it does.

Everything in Astra — the lexer, the parser, the bytecode compiler, the virtual machine — is written from the ground up in C++17, by a single developer. No forked interpreter, no borrowed runtime. The tri-state boolean, the modifier system, and the structured when/then error handling all came from the same instinct: real-world logic is rarely a clean true or false, and a language should be honest about that.

Astra is free and open source under MIT, built in the open, one feature at a time.

How Astra got here.

2026
First lines
Lexer and parser written from scratch in C++ — the earliest version could barely store a variable.
2026
Bytecode VM
Moved from tree-walking to a compiled bytecode VM with a real call stack, enabling functions and recursion.
2026
Chains and modifiers
The 4-in-1 chain abstraction and before/after modifiers shipped, giving Astra its signature features.
2026
v1.0
Power modules, file I/O, JSON, pointers, structured error handling, and a VS Code extension.

Try it, break it, tell us what's missing.

Astra is still young. The fastest way to shape where it goes is to write something in it.

Free and open source, licensed under MIT.