What is it, really?

Every programming language makes a trade. Some are fast but hard (Rust). Some are easy but slower (Python). Quaryn's whole reason to exist is to refuse that trade -- to be easy to read and hard to crash at the same time.

A Quaryn file declares its powers

Here is Quaryn's signature -- the mark that makes a .qry file unmistakable. A Quaryn program opens by stating, in brackets, exactly what it's allowed to touch: the network, the file system, and so on. And it isn't a comment or a suggestion -- the compiler enforces it.

uses [net, threads]

fn main() {
    spawn(() => serve(8080))
}

// forgot to declare it?
fn main() {
    http_get(url)
}
error: `http_get` needs network access,
  but this file does not declare it
  → add `uses [net]` at the top

The rest of the tells

You can spot Python by its indentation, JavaScript by its const and arrows. Here are the tells that make a .qry file unmistakably Quaryn -- each one shown in real code.

fn greet(name: String) -> String {
    f"Hello, {name}!"
}

let total = 42        // fixed forever
let mut count = 0    // this one may change
count = count + 1

fn load(url: String) -> Result<String, String> {
    let resp = http_get(url)?   // if it fails, stop here neatly
    Ok(resp.body)
}

match state {
    State::Idle => println("waiting"),
    State::Running(t) => println(f"tick {t}"),
    State::Done(msg) => println(msg),
}

let order: Result<CreateOrder, String> = req.body.json_decode()

let line = names |> map(n => n.shout()) |> join(", ")

Safety without the scary part

Rust is famously safe, but it asks you to learn "lifetimes" -- a web of symbols that scares newcomers away. Quaryn keeps the safety and throws the symbols in the bin.

fn longest<'a>(x: &'a str,
            y: &'a str) -> &'a str {
    // the 'a annotations are the hard part
}

fn longest(x: String, y: String) -> String {
    if x.len() > y.len() { x } else { y }
}

How it translates

If you know any other language, you already half-know Quaryn. Here's the same idea side by side -- first the words you write, then the commands you run.

Notice the pattern: one tool, quaryn, does everything -- run, check, test, explore. No separate installers, formatters, or build files to learn.

The whole vocabulary

Quaryn is deliberately small -- you can hold the entire language in your head. These are essentially all of its keywords and built-in actions.

fn       define a function
let      name a value
mut      …and allow it to change
struct   a data record
enum     a set of choices
impl     attach methods to a type
interface a shared capability
match    handle every case
if else  branch
while for loop
return   hand back a value
import   use another file
uses     declare your powers

println          show a line
http_get http_post call an API
http_serve       become an API
json_decode      JSON → your types
spawn channel    do things at once
sha256 verify    hashing & signatures
crypto_encrypt   lock data
crypto_decrypt   unlock data
read_file write_file files
now_ms sleep_ms  time
assert           check while testing

Security and web features that are add-on libraries elsewhere are built into Quaryn itself -- encryption, signatures, JSON, and an HTTP server all ship in the box.

Best things to build with it

Quaryn was designed around one promise: fast memory, fast iteration, and APIs that just work. That points at a few sweet spots.

One language, three speeds

Quaryn makes its three execution strategies explicit. The exact same source can run three ways -- a simple readable mode, a portable mode, and a top-speed mode that turns hot math into real machine code -- and you pick. Here is the same work timed on all three, next to the four languages Quaryn draws from.

You can check its work

Three engines sound like three chances to get it wrong. It's actually the opposite, and it's the reason to trust a language this young.