A programming language by Hamza Arya2.0.0Stable release

Arya.

Readable by design.
Native by default.

My independent programming language, built from the compiler to the tools around it. Write expressive .arya source, work with exact decimals, and compile through C11 into a native executable.

ARYA / NATIVE TOOLCHAIN2.0.0
ONE SOURCE. A NATIVE APPLICATION.
.aryaC11executable

Self-hosted compiler · Native runtime
Exact-decimal standard library

A RELEASE BUILD / EXPECTED SESSION
$ arya build invoice.arya -o invoice --release
$ ./invoice
65.84
Runs directly on its targetRead invoice.arya
CompilerSelf-hosted in AryaBuild targetNative via C11Standard library28 public modulesLicenseApache 2.0
01An independent language

From an idea
to a toolchain.

I started Arya to explore what it takes to build a language people can read, understand and use for real work.

That work now includes a self-hosted compiler, a native runtime, a checker, a formatter, a test runner and a language server. The current native implementation compiles through C11. The earlier JavaScript implementation remains a separate compatibility profile.

01 / EXPRESS THE IDEA

Code that follows the flow.

Functions, input-first pipelines, guards, indexed loops and composable records keep everyday application logic direct. Optional type contracts add feedback where you need it.

02 / CHOOSE THE NUMBERS

Exact where it matters.

Use binary64 numbers for ordinary arithmetic. Use decimal strings, money values and explicit rounding policies for financial calculations.

03 / OWN THE BUILD

A native path to delivery.

The compiler and development tools run natively. A built application runs with its target system libraries and any dependencies its features explicitly select.

02Read the language

Small expressions.
Practical programs.

5 examples of the native language. Explore the syntax, inspect the expected result, and copy a complete source file to try with the matching SDK.

leaders.arya
use std "list" as list

const people = [
  {name: "Hamza", active: true, score: 85},
  {name: "Samira", active: true, score: 95},
  {name: "Omar", active: false, score: 100}
]

const leaders = people |>
  list.filter("active") |>
  list.sortBy("score", "desc") |>
  list.take(2)

for person at position in leaders {
  print(position + 1, person.name)
}
Expected native output
1 Samira
2 Hamza

A transformation you can read in order.

Pipelines pass their input as the first argument. Filter, sort and take a new list, then keep the position visible with an indexed loop.

Read the guide

Source and expected results are shown here; execution happens locally. Use the matching native SDK for record composition. HTTP examples stay running until stopped.

03Built from the language up

A compiler.
A working environment.

Language design includes everything after the first line: checking an idea, explaining a mistake, testing a rule and producing an application.

01 / WRITEUTF-8 .arya source02 / ANALYZEParse, resolve & check03 / COMPILEC11 + native libraries04 / DELIVERTarget executable

Self-hosted compiler

The compiler is written in Arya. Its frontend handles lexical scopes, module graphs, optional annotations and source diagnostics before generating C.

A complete CLI workflow

Create, check, format, lint, test, run and build. Native run caching reuses unchanged builds; debug and sanitizer options support investigations.

Native language services

Run arya lsp --stdio with a compatible editor. The optional desktop editor adapter is an editor-host component, packaged separately from the standalone SDK.

THE EVERYDAY LOOParya check main.aryaarya test main.test.aryaarya fmt main.aryaarya build main.arya -o app
04The standard library

28 modules.
A useful foundation.

Shipped with the native SDK. Start with collections and files; reach for money, validation or an interface when the application calls for it.

01

Money & business

Exact arithmetic, explicit currency policies, prepared invoices and balanced journals.

decimalmoneyfinanceaccounting
02

Data & files

Native file operations, structured data and incremental CSV consumption.

fspathjsoncsvio
03

Application foundations

Collections, ordinary arithmetic, dates and cooperative asynchronous work.

listmathdatetimeasync
04

Trust & feedback

Input validation, cryptography, diagnostics and native automated tests.

authvalidatesecurityenvdebuglogtesting
05

Interfaces

Direct native controls, HTTP endpoints and browser interfaces, with a separate macOS web-view host.

webuiguidesktop
06

Explicit connections

Native process helpers and opt-in Python or MySQL integrations.

processruntimepythonmysql

The native release adds gui for direct AppKit, GTK and Win32 controls and auth for native authentication. Python requires an interpreter and MySQL requires a native client SDK. The older desktop web-view host remains macOS-specific. Native imports use use std and use arya; npm imports belong to the earlier Node profile.

05Part of a larger practice

Language design.
Application thinking.

Arya sits alongside my editor and accounting projects. Each explores a different part of making useful software.

06Build your first program

Choose a starting point.
Make it yours.

Choose a qualified package from the native downloads page and use it with a C11 toolchain. Once arya is on your PATH, create a project and use the same commands to check, run and build it.

First, prepare the native SDK

From a complete source checkout or snapshot matching the selected SDK version, build the SDK and expose its tools to this shell. The full SDK build needs POSIX tools, C11, C++20 and Perl. An installed matching SDK can skip this step.

make native-sdk
./bin/arya --version
export PATH="$PWD/.build/independent:$PATH"
Read installation and platform requirements
Terminal / Command line
arya create my-app --template cli
cd my-app
arya check main.arya
arya run main.arya -- 19.95 3
arya build main.arya -o ./my-app --release

ENTRYmain.arya

The CLI starter includes main.test.arya. Run arya test main.test.arya to check its calculations.

Follow the native getting-started guide
Release status

A stable native release.
A clearly defined scope.

2.0.0 is available through versioned, verified downloads. The download manifest records exact files, checksums, tested targets and installation requirements.

macOS · Apple silicon
ARM64 Mac. SDK and bundled extension: macOS 15+. Application ZIPs: macOS 26+. Apple command-line tools are needed to compile programs. Qualified native compiler and AppKit widgets. The bundled VSIX includes its SDK. The two app collections contain twelve standalone native applications and do not need the SDK to run. Downloads are ad-hoc signed, without Apple notarization.
Linux · x64
Tested on Ubuntu 24.04 x64. A C11 toolchain is needed to compile; GUI builds need GTK 3 development files and GUI execution needs GTK 3 runtime libraries and a display. Qualified native compiler, SDK installation and actual GTK controls. Use the portable VSIX with this installed SDK. Other Linux distributions and architectures are not implied by this qualification.
Windows · x64 with Cygwin
Windows x64 with a matching Cygwin installation, runtime DLLs and C toolchain. Install the SDK from a Cygwin terminal. Qualified PE compiler, direct Win32 controls, relocation and installer. Cygwin DLLs are required and are not bundled. For native Windows VS Code, use the portable VSIX and set the real Windows arya.exe path. MSVC/MinGW and the optional Python bridge are not qualified.
Deployment boundaries
Build for the destination OS / CPU. HTTP/1 has no built-in TLS. Cross-compilation and Wasm are not supplied. Selected integrations retain their own external dependencies.
Earlier Node profile
The published 1.3.0-alpha.9 npm preview is separate. Installing it does not install the native SDK.
07Learn by working through it
12 lessons / 3 stages / Native Arya

Read it. Predict it.
Then make it run.

Start with one result and build toward a tested, exact-decimal command-line program. Each lesson gives you source, a knowledge check, a change to make and a worked solution.

Open the learning path
08Keep the reference nearby

The details,
when you need them.

Versioned Markdown guides for the published native SDK. The learning path also preserves its earlier source snapshot and worked exercises.