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
squares = [1, 2, 3].map { |n| n * n }
squares.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.

Ruby-Inspired Syntax

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

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.