SkillAgentSearch skills...

Aro

ARO is a declarative language for specifying business features in a human-readable format that can be compiled and executed. Features are expressed as Action-Result-Object statements.

GenerateConvertImprove

Install / Use

/learn @arolang/Aro
About this skill

Quality Score

0/100

Supported Platforms

Universal

README

<p align="center"> <img src="./Graphics/logo.png" alt="ARO Logo" width="400"> </p> <p align="center"> <strong>Business Logic as Language</strong><br> A declarative language where code reads like documentation </p> <p align="center"> <a href="https://arolang.github.io/aro/">Website</a> · <a href="https://github.com/arolang/aro/wiki">Documentation</a> · <a href="https://github.com/arolang/aro/releases/latest/download/ARO-Language-Guide.pdf">Language Guide (PDF)</a> · <a href="https://github.com/arolang/aro/discussions">Discussions</a> · <a href="https://social.uitsmijter.io/@aro">Mastodon</a> </p>

What is ARO?

ARO is a programming language designed to express business features in a form that both developers and domain experts can read. Every statement follows a consistent grammatical pattern:

<Action> the <Result> preposition the <Object>.

This constraint is intentional. When there is only one way to express an operation, code review becomes trivial and onboarding becomes fast. ARO code reads like a description of what happens, not instructions for how to make it happen.

(createUser: User API) {
    <Extract> the <data> from the <request: body>.
    <Validate> the <data> against the <user: schema>.
    <Create> the <user> with <data>.
    <Store> the <user> into the <user-repository>.
    <Emit> a <UserCreated: event> with <user>.
    <Return> a <Created: status> with <user>.
}

A compliance officer can audit this. A new developer can understand it in seconds. The code is the documentation.

Why This Exists

Right, here's the thing. This project exists because I wanted to see what happens when you let AI loose on a domain you don't feel confident enough to tackle on your own, but you're savvy enough to spot when it's talking rubbish. Turns out, the AI won't stop you doing daft things - it'll happily help you build something bonkers if you ask it to. But the real surprise? I've ended up learning more about language design, parsers, and compiler theory than I ever expected. Never thought I'd care about lexers and ASTs, but here we are. Sometimes the best education comes from poking at something you probably shouldn't, with tools that don't know any better.

Features

Contract First APIs

HTTP routes are defined in an OpenAPI specification. Feature sets are named after operation identifiers. No routing configuration in code.

# openapi.yaml
paths:
  /users:
    get:
      operationId: listUsers

(listUsers: User API) {
    <Retrieve> the <users> from the <user-repository>.
    <Return> an <OK: status> with <users>.
}

Event Driven Architecture

Feature sets respond to events rather than being called directly. Emit an event and handlers execute automatically. Add new behaviors by adding handlers without modifying existing code.

(Send Welcome Email: UserCreated Handler) {
    <Extract> the <user> from the <event: user>.
    <Send> the <welcome-email> to the <user: email>.
    <Return> an <OK: status> for the <notification>.
}

Native Compilation

Compile to standalone binaries. No runtime installation required on target systems.

aro build ./MyApp
./MyApp

Built in Services

HTTP server and client, file system operations with directory watching, and TCP sockets are available without external dependencies.

(Application-Start: File Watcher) {
    <Watch> the <file-monitor> for the <directory> with "./data".
    <Keepalive> the <application> for the <events>.
    <Return> an <OK: status> for the <startup>.
}

Extensible Actions

When the 50+ built-in actions are not enough, write custom actions in Swift or distribute them as plugins through Swift Package Manager.

Plugin Qualifiers

Extend the language with custom value transformations. Plugins can register qualifiers that work on Lists, Strings, and other types.

Compute the <random-item: pick-random> from the <items>.
Compute the <sorted: sort> from the <numbers>.
Log <list: reverse> to the <console>.

Write plugins in Swift, Rust, C, or Python. Qualifiers work in both interpreter and compiled binary modes.

Happy Path Philosophy

Write only the success case. Errors are reported automatically in business terms. When a user cannot be retrieved, the message says exactly that.

Platform Support

ARO runs on macOS, Linux, and Windows. Most features work across all platforms.

| Feature | macOS | Linux | Windows | |---------|:-----:|:-----:|:-------:| | Core Runtime | | Interpreter (aro run) | ✅ | ✅ | ✅ | | Syntax checking (aro check) | ✅ | ✅ | ✅ | | Native compilation (aro build) | ✅ | ✅ | ❌⁴ | | Networking | | HTTP Server | ✅ | ✅ | ✅¹ | | HTTP Client | ✅ | ✅ | ✅ | | Socket Server | ✅ | ✅ | ✅¹ | | Socket Client | ✅ | ✅ | ✅¹ | | File System | | File Operations | ✅ | ✅ | ✅ | | File Monitoring | ✅ | ✅ | ✅² | | Large File Streaming | ✅ | ✅ | ❌⁵ | | Data Processing | | HTML Parsing | ✅ | ✅ | ✅ | | JSON/YAML Processing | ✅ | ✅ | ✅ | | Developer Tools | | Language Server (LSP) | ✅ | ✅ | ❌³ | | Swift Plugins | ✅ | ✅ | ✅ |

¹ Uses FlyingFox with polling-based networking (no SwiftNIO) ² Uses polling-based monitoring instead of native events ³ LanguageServerProtocol library doesn't support Windows yet ⁴ LLVM not available in Windows CI environment ⁵ URL.lines not available on Windows; use Read + Split instead

Quick Start

(Application-Start: Hello World) {
    <Log> "Hello from ARO!" to the <console>.
    <Return> an <OK: status> for the <startup>.
}

Save as main.aro in a directory called HelloWorld, then:

aro run ./HelloWorld

Documentation

The complete language guide is available as a PDF in the Releases page, or download the latest version directly. It covers:

  • The ARO mental model and philosophy
  • Statement anatomy and feature sets
  • Data flow and the event bus
  • OpenAPI integration
  • Built in services (HTTP, files, sockets)
  • Custom actions and plugins
  • Native compilation
  • Patterns and practices

For a detailed look at the implementation, see OVERVIEW.md.

Installation

macOS (Homebrew)

The easiest way to install ARO on macOS:

brew tap arolang/aro
brew install aro

Verify installation:

aro --version

Binary Releases

Pre-built binaries are available for all platforms:

macOS (ARM64):

curl -L https://github.com/arolang/aro/releases/latest/download/aro-macos-arm64.tar.gz | tar xz
sudo mv aro /usr/local/bin/
sudo mv libARORuntime.a /usr/local/lib/

Linux (x86_64):

curl -L https://github.com/arolang/aro/releases/latest/download/aro-linux-amd64.tar.gz | tar xz
sudo mv aro /usr/local/bin/
sudo mv libARORuntime.a /usr/local/lib/

Windows (x86_64): Download the latest release from GitHub Releases and add to PATH. Keep aro.exe and libARORuntime.a in the same directory.

Build from Source

See the Building from Source section below for detailed instructions.

Building from Source

ARO is written in Swift 6.2 and uses Swift Package Manager.

Dependencies

Building ARO from source requires:

| Dependency | Version | Required For | |------------|---------|--------------| | Swift | 6.2+ | Core compiler and runtime | | LLVM | 20 | Native compilation (aro build) | | Clang | 20 | Linking compiled binaries |

Note: LLVM and Clang are only required for the aro build command (native compilation). The interpreter (aro run) works without them.

macOS

Xcode 16.3 or later includes Swift 6.2. Install LLVM 20 via Homebrew:

brew install llvm@20

Then build:

git clone https://github.com/arolang/aro.git
cd aro
swift build -c release

The binary is at .build/release/aro.

If LLVM is installed in a non-standard location, set the LLVM_PATH environment variable:

export LLVM_PATH=/opt/homebrew/opt/llvm@20  # Apple Silicon default
export LLVM_PATH=/usr/local/opt/llvm@20     # Intel Mac default

Linux

Install Swift 6.2 from swift.org. Install LLVM 20:

# Ubuntu/Debian
wget https://apt.llvm.org/llvm.sh
chmod +x llvm.sh
sudo ./llvm.sh 20
sudo apt-get install -y llvm-20-dev clang-20

Then build:

git clone https://github.com/arolang/aro.git
cd aro
swift build -c release

The binary is at .build/release/aro.

Windows

Install Swift 6.2 from swift.org. Ensure the Swift toolchain is in your PATH.

git clone https://github.com/arolang/aro.git
cd aro
swift build -c release

The binary is at .build\release\aro.exe.

Note: Native compilation (aro build) is not yet supported on Windows. Use aro run for interpreter mode. Windows networking uses FlyingFox (polling-based, no SwiftNIO dependency).

Running Tests

Unit Tests

Run Swift unit tests for the parser, runtime, and compiler:

swift test

Integration Tests

Run integration tests for all examples (two-phase: interpreter + native binary):

# Run all examples
./test-examples.pl

# Run specific examples
./test-examples.pl HelloWorld Calculator HTTPServer

# Verbose output
./test-examples.pl --verbose

# Filter by pattern
./test-examples.pl --filter=HTTP

The integration test framework is modular and located in Tests/AROIntegrationTests/:

  • 17 modules organized by responsibility
  • Two-phase testing (run + build)
  • Automatic type detection (console, HTTP, socket, file)
  • Pattern matching with placeholders
  • 109 unit tests validating framework behavior

See Tests/AROIntegrationTests/README.md for complete documentation.

Examples

The Examples/ directory contains 50+ working applications demonstrating various ARO features:

| Categ

arolang

View profile

View on GitHub
GitHub Stars9
CategoryProduct
Updated10h ago
Forks0
arolang/aro

Languages

Swift

Security Score

85/100

Audited on Apr 2, 2026

No findings