Hyper is a compiled language with a Python-shaped surface: readable syntax, native performance goals, and a path toward AI-scale workloads. Until now it lived as source on GitHub. Today that changes.

Hyper 0.1.0 is the first public release.

Not a crates.io package with a polished installer. Not a finished language. A tagged baseline you can clone, build, and run — with a clear contract for what works and what does not.

What 0.1.0 is

Hyper 0.1.0 ships a real toolchain:

  • A language frontend (scanner, parser, typecheck)
  • A Cranelift compiler path (hyper compile)
  • A transitional interpreter path (hyper run)
  • Ahead-of-time artifacts (--emit-exe, --emit-obj, --emit-ir)
  • Multi-platform CI smokes
  • Documentation (mdBook under doc/)

The design bets have not changed: Python-like readability, serious compilation, and Rust-inspired safety. Version 0.1.0 is pre-1.0 SemVer — the surface can still evolve before 1.0.

What shipped

Language core

Everyday Hyper works on both run and compile:

  • let / let mut, functions (fn / def)
  • if / elif / else, while, for / for-in, ternary expressions
  • f-strings, lists, dicts, typed bindings (Array[T], Dict[K, V])
  • break / continue (rejected inside @parallel bodies)

Structs and modules

  • Fields, methods, __init__
  • pub / mut on fields and methods
  • import / from … import
  • Traits: method name + arity checks (no generics yet)
  • ref parameters: mutable bindings; struct instances share field storage

Errors

Hyper does not use try / except. This release has:

  • raise
  • raises on functions
  • handle … else …

Builtins and I/O (compile path)

  • print, input(), clock()
  • open / with, file methods, open_mmap
  • import json
  • Collection helpers (len, append, keys)
  • A full string method set on the compile path

Decorators

  • @parallel / @vectorize on for
  • Interpreter: real threads for outlineable @parallel
  • Compiler: sequential loops with the same per-index results

Toolchain

cargo run -- run program.hyp
cargo run -- compile program.hyp
cargo run -- compile program.hyp --emit-ir
cargo run -- compile program.hyp --emit-obj
cargo run -- compile program.hyp --emit-exe
cargo run -- typecheck program.hyp

CI covers core language, I/O, JSON, mmap, strings, break/continue, raise/handle, traits, pub/mut, ref, and vectorize smokes.

Honest gaps

0.1.0 is a first release, not a finished product. Known limitations include:

  • Generics / a full trait system
  • Shared ref for list / dict / array payloads
  • Threaded @parallel and SIMD @vectorize on the compile path
  • Full Python / stdlib / NumPy parity
  • Production GPU codegen

run is still the more complete path for some programs. compile is catching up. The docs say what works and what does not.

Why this release matters

A first release is a line in the sand.

It says: here is Hyper at this point. Here is what you can build and run. Here is what we do not claim yet.

Hyper is no longer only an experiment in a private tree. It is a public 0.1.0 with a compiler, an interpreter, CI, and docs — and a clear list of what comes next.

Try it

Build from source:

git clone https://github.com/muhammadyusufpov/hyper.git
cd hyper
cargo build
cargo run -- run your_file.hyp
cargo run -- compile your_file.hyp

Docs: doc/ (mdBook). License: MIT OR Apache-2.0.

Release: Hyper 0.1.0