v0.1.1 — Early preview

Object-oriented.
Clean by design.

Sapphire is a Ruby-inspired programming language with gradual typing, first-class blocks, and a clean object model. No magic. No sigils. Just elegant code.

Get started View on GitHub

$ sapphire run hello.spr

hello.spr

class Greeter {
  attr name: String

  def greet() -> String {
    "Hello, #{self.name}! Welcome to Sapphire."
  }
}

g = Greeter.new(name: "world")
print g.greet()

# Blocks, iterators, type annotations — all built in
[1, 2, 3].map { |n| n * n }.each { |n| print n }

See the language

Real examples from the standard library and documentation — no toy snippets.

class Shape {
  attr color = "red"

  def area() { 0 }

  def describe() {
    "A #{self.color} shape"
  }
}

class Rectangle < Shape {
  attr width: Int
  attr height: Int

  def area() {
    self.width * self.height
  }

  def describe() {
    super.describe() + " (#{self.width}x#{self.height})"
  }
}

r = Rectangle.new(width: 4, height: 5)
print r.describe()   # A red shape (4x5)
print r.area()       # 20
print r.is_a?(Shape) # true

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# Functional iteration with blocks
doubled = numbers.map { |n| n * 2 }
evens   = numbers.select { |n| n % 2 == 0 }
total   = numbers.reduce(0) { |acc, n| acc + n }

print "sum: #{total}"
print "any > 8? #{numbers.any? { |n| n > 8 }}"
print "all > 0? #{numbers.all? { |n| n > 0 }}"

# yield lets you build your own iterators
def repeat(n: Int) {
  i = 0
  while i < n {
    yield(i)
    i = i + 1
  }
}

repeat(3) { |i| print "step #{i}" }

# Annotations are optional — add them where you want safety

def clamp(value: Int, min: Int, max: Int) -> Int {
  if value < min      { min }
  elsif value > max   { max }
  else                { value }
}

print clamp(5, 1, 10)   # 5
print clamp(-3, 1, 10)  # 1
print clamp(99, 1, 10)  # 10

def abs(n: Int) -> Int {
  return -n if n < 0
  n
}

def factorial(n: Int) -> Int {
  return 1 if n <= 1
  n * factorial(n - 1)
}

print factorial(6)  # 720

# raise / begin / rescue — clean and composable

def parse_age(s: String) -> Int {
  age = s.to_i
  raise "age must be positive" if age <= 0
  age
}

begin
  print parse_age("25")  # 25
  print parse_age("0")   # raises
rescue e
  print "bad input: #{e}"
end

# Inline rescue inside a function body
def safe_divide(a: Int, b: Int) -> Int {
  a / b
rescue e
  print "cannot divide by zero"
  0
}

print safe_divide(10, 2)  # 5
print safe_divide(10, 0)  # 0

Built with intention

Every design decision in Sapphire has a reason. No magic, no surprises.

Everything is an Object

Primitives like Int, Bool, and String are objects with methods. Call .even?, .upcase, or .times directly on literals.

Blocks & Iterators

First-class blocks and yield make iteration expressive. Build your own higher-order functions naturally.

Gradual Typing

Add type annotations where you want compile-time safety. Leave them off where you want flexibility. Enforced at runtime when present.

Dual Execution

Runs on a tree-walk interpreter today. A bytecode VM is experimental and in active development — it will become the default runtime.

Ruby-Inspired Syntax

Clean, readable syntax with no sigils or metaprogramming surprises. Familiar to Ruby developers, approachable to everyone.

Interfaces as Mixins

Interfaces compose behavior, not just types. Mix them into classes for clean, reusable functionality without multiple inheritance.

Get started

Use facet — the official Sapphire toolchain manager — to install Sapphire and create projects.

1

Install facet

$ cargo install --git https://github.com/sapphire-project/facet

Or grab a pre-built binary from the facet releases page.
2

Install the Sapphire toolchain

$ facet sapphire install latest
3

Create and run your first project

$ facet new myproject && cd myproject

$ facet run

Hello, Sapphire!

Read the tutorial Browse examples

Object-oriented. Clean by design.