The Olive Programming Language by Vince SwuThe Olive Programming Language by Vince Swu

The Olive Programming Language

Vince Swu

Completed work

Software Architect

Software Engineer

Systems Engineer

Python

Rust

Computer Software

Overview

A general-purpose systems language that's easy to read, fast to run, and keeps your memory safe.

Olive was built for when you want the speed of a low-level language without the headache of complex syntax. It uses a clean, indentation-based structure and a smart ownership model to provide consistent performance without a garbage collector.

Why Olive?

Clean Syntax: No braces, no semicolons. Indentation defines the structure, keeping your code readable and consistent.

Memory Safety, No Annotations: The compiler infers ownership and frees values deterministically; references are borrow-checked, and a generation-checked allocator turns anything the analysis can't prove into a precise runtime fault instead of corruption. No garbage collector, no lifetime syntax.

Blazing Fast: Optimized to native code via the Cranelift backend. It's designed to run close to the metal with zero-cost abstractions.

Modern Concurrency: True async/await that's easy to use and extremely efficient.

C / Rust Interop: Interface with C or Rust libraries through a C-compatible ABI with built-in FFI support.

Python Interop: Import any Python module directly. Types are inferred automatically from .pyi stubs, so glm.vec3 stays glm.vec3 through the type checker. Native collections pass with zero-copy bidirectional proxies.

Friendly Errors: When things go wrong, the compiler tells you exactly where and why, with suggestions on how to fix it.

A Taste of Olive

// A generic function to calculate average
fn average[T: Numeric](numbers: [T]) -> float:
    let mut total = 0.0
    for n in numbers:
        total += float(n)
    return total / float(len(numbers))

async fn process_data(data: [int]):
    print(f"Processing {len(data)} items...")
    let avg = average(data)
    print(f"Result: {avg:.2f}")

fn main():
    let data = [10, 20, 30, 40, 50]
    // Spawning an async task
    async:
        await process_data(data)

Getting Started

Linux and macOS:

curl -sSL https://raw.githubusercontent.com/ecnivslabs/olive/master/install.sh | sh

Windows: download from the releases page.

Then:

pit new my_app
cd my_app
pit run

Documentation

Introduction: Philosophy and goals.

Basics: Variables, types, and control flow.

Ownership: How memory safety works.

Generics: Writing reusable code.

Traits: Defining shared behavior between types.

C / Rust Interop (FFI): Calling C or Rust code and using unsafe.

Python Interop: Typed Python integration with automatic .pyi stub introspection.

Standard Library: What's in the box.

Full Index: Everything in one place.

Like this project

Completed work

Posted Aug 9, 2026

Designed and built a memory-safe systems language with native compilation, ownership inference, async/await, FFI, and Python interoperability.

Likes

Views