Python’s syntax.
Machine code.
Every core.

parallelism

The parallel version changes one word

200 simulated price paths, 50,000 steps each, an EMA-crossover strategy with stop-losses — per-step state that cannot be vectorized. The serial and parallel programs differ by a single keyword.

eqs = [0.0] * paths
for p in range(paths):    r = run_path(p + 1, steps)
    eqs[p] = r.equity

eqs = [0.0] * paths
parallel for p in range(paths):    r = run_path(p + 1, steps)
    eqs[p] = r.equity

safety

Your data race doesn’t compile

Every threaded language has the same horror story: works in testing, corrupts data in production. pyalt’s answer: assigning to shared state inside parallel for is rejected before the program ever runs. This is the compiler’s actual output:

race.pya:6:5: error: cannot assign to outer variable 'total'
inside parallel for — iterations race; write results into an
output list instead
        total = total + score(i)
        ^

The one blessed pattern — writing results into distinct slots of an output list — is race-free by construction. And since pyalt functions cannot touch globals, every function called from a parallel loop is thread-safe automatically. Appending to a shared list, writing a shared dict, returning from inside the loop: all compile errors, each with an explanation.

benchmarks

Measured, verified — losses included

Monte Carlo backtest, 10 million loop iterations, identical logic in each implementation, byte-identical outputs, median of 5 runs on Windows 11 x64. The harness re-verifies pyalt’s output against CPython’s on every run.

Serial string- and dict-heavy code is the weaker case — roughly 2.5–5x over CPython, whose string and dict internals are already optimized C; parallel for reached 15x on the same text workload. Full methodology in BENCHMARKS.md; reproduce everything with python bench/harness.py.

language

A real language, not a demo

Every feature below is covered by the 216-test suite that CI runs on Windows and Linux. Annotate function parameters; everything else is inferred at compile time.

class Result:
    equity: float
    trades: int
    wins: int

def run_path(seed: int, steps: int) -> Result:
    price = 100.0       # float, inferred
    ...
    return Result(equity, trades, wins)

try:
    values = parse_row(line)
    total = total + values[2]   # bounds-checked
except as msg:
    print(f"skipping row: {msg}")

raise "empty input file"

from utils import clean
import stats

rows = clean(read_lines("data.csv"))
m = stats.mean(rows)
# the import graph compiles into ONE binary;
# import cycles are compile errors

> pyalt buildpy metrics.pya
build\metrics.pyd

# then, in ordinary Python:
import metrics
metrics.sharpe(returns)   # native speed

• types: int · float · bool · str · list[T] · dict[K,V] · set[T]
• dicts & sets are insertion-ordered
• f-strings
• mark-sweep GC · gc_collect()
• CLI builtins: args() · input() · exists() · exit()
• PYA_THREADS · PYA_GC env knobs

read before porting

Python’s syntax — not always Python’s semantics

Machine performance costs some Python behaviors. These are the differences that matter, stated up front:

• int is 64-bit, not arbitrary precision. 10**19 overflows in pyalt and works in Python; the usable range ends at ±9.2×10¹⁸.
• Strings are UTF-8 bytes: len(), indexing, and slicing count bytes. Identical to Python for ASCII, different for non-ASCII text.
• float matches CPython bit-for-bit in arithmetic (verified by the harness); // and % follow Python’s floor/sign rules. Float formatting can differ in edge cases.
• Errors are messages, not objects. except catches everything; there is no exception class hierarchy yet.
• No None; conditions must be bool; a variable keeps one type. All three are compile errors rather than silent differences.

install

Running in three steps (Windows x64)

1. 1

   Download and unzip

   Get pyalt-0.1.0-windows-x64.zip (7 MB, self-contained — no Python required) and unzip anywhere, e.g. C:\pyalt.

2. 2

   Add it to your PATH

   The included script appends bin\ to your user PATH. Windows requires downloaded scripts to be run explicitly — then open a new terminal:

   PowerShellcopy

   powershell -ExecutionPolicy Bypass -File .\install.ps1

3. 3

   Compile something

   Building needs a C compiler on the machine — MSVC (free Build Tools), gcc, or clang, detected automatically. Save as hello.pya:

   hello.pyacopy

   def fib(n: int) -> int:
       if n < 2: return n
       return fib(n - 1) + fib(n - 2)
   
   print(f"fib(30) = {fib(30)}")

   run itcopy

   pyalt run hello.pya      # compile and run
   pyalt build hello.pya    # build\hello.exe — ~200 KB, zero deps
   pyalt buildpy hello.pya  # build\hello.pyd — import from Python

Linux and macOS run from source — python3 pyalt.py run prog.pya (Python 3.10+); the full test suite passes on Ubuntu in CI, less field-tested than Windows.

SHA256 pyalt-0.1.0-windows-x64.zip
A889628D820D0D84E8584FE792F56524C6F3A8EE13A8DA62D943B95560BDC60B

how it works

Source to machine code, no interpreter in between

The runtime is a single C header (~1,300 lines): a conservative mark-sweep garbage collector, insertion-ordered hash tables with cached string hashes, zero-copy string views, a thread pool for parallel for, and bounds checks throughout. The compiler (~3,700 lines) is currently bootstrap-hosted in Python — the usual arrangement for a young language; the release package is self-contained, and compiled output never involves Python.

Compile errors carry position, context, and a suggestion:

prog.pya:3:19: error: '+' has mismatched operand types: int and str
— to build a string, convert with str(...) or use an f-string
        total = total + line
                      ^

roadmap

What comes next, in order

• NumPy array interop — zero-copy
• Linux support promoted from experimental
• None / Optional
• class inheritance
• self-hosted compiler
• bundled C backend

Development practice: no change merges without tests, and the benchmark harness verifies pyalt’s outputs against CPython’s on every run.