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.
.aryaC11executableSelf-hosted compiler · Native runtime
Exact-decimal standard library
$ arya build invoice.arya -o invoice --release
$ ./invoice
65.84From 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.
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.
Exact where it matters.
Use binary64 numbers for ordinary arithmetic. Use decimal strings, money values and explicit rounding policies for financial calculations.
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.
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.
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)
}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.
Source and expected results are shown here; execution happens locally. Use the matching native SDK for record composition. HTTP examples stay running until stopped.
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.
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.
arya check main.aryaarya test main.test.aryaarya fmt main.aryaarya build main.arya -o app28 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.
Money & business
Exact arithmetic, explicit currency policies, prepared invoices and balanced journals.
decimalmoneyfinanceaccountingData & files
Native file operations, structured data and incremental CSV consumption.
fspathjsoncsvioApplication foundations
Collections, ordinary arithmetic, dates and cooperative asynchronous work.
listmathdatetimeasyncTrust & feedback
Input validation, cryptography, diagnostics and native automated tests.
authvalidatesecurityenvdebuglogtestingInterfaces
Direct native controls, HTTP endpoints and browser interfaces, with a separate macOS web-view host.
webuiguidesktopExplicit connections
Native process helpers and opt-in Python or MySQL integrations.
processruntimepythonmysqlThe 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.
Language design.
Application thinking.
Arya sits alongside my editor and accounting projects. Each explores a different part of making useful software.
.arya → C11 → executableArya
My compiler, native runtime, libraries and developer tools. Versioned SDK downloads list the qualified targets and their required dependencies.
Source repository
Arya Code
Arya Code 2.0 brings native Arya tooling, a custom formatter, four themes, two icon packs and 32 editable motions into my desktop workspace. Live Server preview and local service controls support development. Built by Hamza Arya; download availability is verified per platform.
Explore the IDE
Arya Ledger
The accounting product that gives language work a practical context. Its documented JavaScript integration remains pinned to the earlier compiler.
Explore the productChoose 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"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 --releaseENTRYmain.arya
The CLI starter includes main.test.arya. Run arya test main.test.arya to check its calculations.
Follow the native getting-started guideA 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.
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 pathThe 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.
Installation
SDK layout, source builds and platform requirements.
READ GUIDE / .MDLanguage reference
Syntax, records, types, modules and evaluation rules.
READ GUIDE / .MDStandard library
The public native modules and their entry points.
READ GUIDE / .MDNative profile
Memory, scheduling, compatibility and current limits.
READ GUIDE / .MDCLI & tools
Check, run, test, format, build and language-server commands.
READ GUIDE / .MDSDK & editors
Distribute an application or connect a compatible editor.
READ GUIDE / .MD