The Sidef Programming Language

            **   **         ****   *           *********   *********
          * * ** * *        ****   **          ** ** **    ** ** **
           **   **          ****   ***         *********   *  *  *
  **        **        **    ****   *  *        ******      ******
* * *     * * *     * * *   ****   ** **       ** **       ** **
 **        **        **     ****   ******      ******      *  *
       **   **              ****   *  *  *     *********   ***
     * * ** * *             ****   ** ** **    ** ** **    **
      **   **               ****   *********   *********   *

🌟 What is Sidef?

Sidef is a modern, expressive programming language that combines the elegance of Ruby, the versatility of Raku, and the mathematical power of a built-in computer algebra system. It features exact rational arithmetic by default, an extensive number theory library (1,000+ functions), and seamless Perl module integration — making it equally at home for scripting, mathematical research, and general-purpose programming.

# Exact rational arithmetic — no floating-point surprises
say (1/3 + 1/6)         #=> 1/2

# Built-in number theory
say (2**127 - 1)        #=> 170141183460469231731687303715884105727 (Mersenne prime)
say factor(2**128 + 1)  #=> [59649589127497217, 5704689200685129054721]

# Expressive, concise syntax
say 29.primes.map{.square}     #=> [4, 9, 25, 49, 121, 169, 289, 361, 529, 841]

🎯 Who is Sidef for?

Sidef is an excellent choice for:

• Mathematical research and experimentation
• Computational number theory and cryptography
• Project Euler and competitive programming
• Scientific computing and computer algebra
• Rapid scripting and general-purpose automation
• Algorithm prototyping
• Perl developers seeking a higher-level language

🏆 Why choose Sidef?

✨ Featured Capabilities

• 🔢 Exact arithmetic by default
• 🧮 Built-in computer algebra
• 🔬 1,000+ number theory functions
• ♾ Lazy evaluation and infinite sequences
• 🧠 Pattern matching and multiple dispatch
• 📐 Matrices, polynomials and Gaussian integers
• ⚡ Arbitrary-precision arithmetic via GMP/MPFR/MPC
• 📦 Seamless Perl module interoperability
• 🖥 Interactive REPL with built-in help

🚀 Quick Start

Prerequisites

Sidef requires Perl 5.18+ and the following C libraries:

Debian/Ubuntu:

sudo apt-get install libgmp-dev libmpfr-dev libmpc-dev

Arch Linux:

sudo pacman -S gmp mpfr libmpc

Termux:

pkg install perl make clang libgmp libmpfr libmpc

Installation

Via CPAN:

cpan Sidef
# or (skip tests for faster install):
cpan -T Sidef
# or with cpanminus:
cpanm Sidef

Build from source:

git clone https://github.com/trizen/sidef.git
cd sidef
perl Makefile.PL
make
make test
make install

Via AUR:

trizen -S sidef

Platform packages:

• Arch Linux: AUR package
• Slackware: SlackBuilds
• Other systems: See pkgs.org

Hello World

say "Hello, World!"

sidef hello.sf
sidef -E 'say "Hello, World!"'
sidef -i            # start the REPL

Try It Online

Experiment with Sidef instantly at Try It Online without any installation.

🔤 Language at a Glance

Variables and Types

var name   = "Sidef"               # String
var num    = 42                    # Number (exact integer)
var ratio  = 3/7                   # Number (exact rational)
var arr    = [1, 2, 3]             # Array
var hash   = Hash(a => 1, b => 2)  # Hash
var block  = {|n| n.is_prime }     # Block

Functions and Pattern Matching

func greet(name) { "Hello, #{name}!" }
say greet("world")    #=> Hello, world!

# Multi-dispatch / pattern matching
func fib({|n| n == 0 }) { 0 }
func fib({|n| n == 1 }) { 1 }
func fib(n) { fib(n-1) + fib(n-2) }

say fib(10)    #=> 55

Object-Oriented Programming

class Animal(name, sound) {
    method speak { say "#{name} says #{sound}!" }
}

class Dog(name, sound="woof") < Animal {
    method fetch { say "#{name} fetches the ball!" }
}

var d = Dog("Rex")
d.speak    #=> Rex says woof!
d.fetch    #=> Rex fetches the ball!

Functional Programming

var nums = 1..10   # RangeNumber object

# Map, filter, reduce
var evens   = nums.grep { .is_even }              #=> [2, 4, 6, 8, 10]
var squares = nums.map  { |n| n**2 }              #=> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
var total   = nums.reduce { |a, b| a + b }        #=> 55

say evens
say squares
say total

Number Theory

say primes(50, 100)          # array of primes in range [50, 100]
say prime_count(10**9)       # number of primes up to $10^{9}$
say prime(100)               # 100th prime => 541
say 12.divisors              # [1, 2, 3, 4, 6, 12]
say euler_phi(100)           # Euler's totient => 40
say gcd(48, 18)              # => 6
say is_prime(2**521 - 1)     # Mersenne prime check => true

Lazy Evaluation

# Infinite lazy list of primes
var lazy_primes = (2..Inf -> lazy.grep { .is_prime })
say lazy_primes.first(10)    #=> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

⌨️ Command-Line Reference

sidef [options] [script.sf] [script-arguments]

Examples:

sidef -E 'say 10.of { |i| i**2 }'            # one-liner
sidef -i                                     # start REPL
sidef -i script.sf                           # run script in REPL
sidef -C script.sf                           # syntax check
sidef -c -o output.pl script.sf              # compile to Perl
sidef -P 400 -E 'say sqrt(2)'                # 400-bit precision
sidef -O1 script.sf                          # with optimization
sidef -r script.sf                           # deparse to Sidef
sidef -t tests/*.sf                          # run test files

🖥️ Interactive Mode (REPL)

Start the REPL with sidef -i:

$ sidef -i
sidef> say "Hello!"
Hello!
sidef> x = 2**64
18446744073709551616
sidef> x.is_prime
false
sidef> is_prime(2**127 - 1)
true
sidef> 1..10 -> map { .square }.sum
385
sidef> quit

Use -H to open interactive documentation help:

sidef -H

🎯 Code Examples

Classes and Inheritance

class Shape {
    method area { die "Not implemented" }
    method describe { say "I am a #{self.class} with area #{self.area}" }
}

class Circle(r) < Shape {
    method area { Num.pi * r**2 }
}

class Rectangle(w, h) < Shape {
    method area { w * h }
}

Circle(5).describe        #=> I am a Circle with area 78.539...
Rectangle(4, 6).describe  #=> I am a Rectangle with area 24

Functional Array Processing

# FizzBuzz in one line
say (1..20 -> map { |n|
    n%%15 ? "FizzBuzz" : (n%%3 ? "Fizz" : (n%%5 ? "Buzz" : n))
})

# Pipeline style
(1..50).grep { .is_prime } \
       .map  { .square } \
       .first(5) \
       .say    #=> [4, 9, 25, 49, 121]

Number Theory One-Liners

say 100.by { .is_prime }              # first 100 primes
say sum(1..100)                       #=> 5050
say prod(1..10)                       #=> 3628800  (10!)
say { .euler_phi }.map(1..10)         #=> [1, 1, 2, 2, 4, 2, 6, 4, 6, 4]

The Y Combinator

Demonstrating functional programming with the Y combinator:

var y = ->(f) {->(g) {g(g)}(->(g) { f(->(*args) {g(g)(args...)})})}

var fac = ->(f) { ->(n) { n < 2 ? 1 : (n * f(n-1)) } }
say 10.of { |i| y(fac)(i) }     #=> [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]

var fib = ->(f) { ->(n) { n < 2 ? n : (f(n-2) + f(n-1)) } }
say 10.of { |i| y(fib)(i) }     #=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Sierpinski Triangle

ASCII generation of the Sierpinski triangle:

func sierpinski_triangle(n) {
    var triangle = ['*']
    { |i|
        var sp = (' ' * 2**i)
        triangle = (triangle.map {|x| sp + x + sp} +
                    triangle.map {|x| x + ' ' + x})
    } * n
    triangle.join("\n")
}

say sierpinski_triangle(4)

               *
              * *
             *   *
            * * * *
           *       *
          * *     * *
         *   *   *   *
        * * * * * * * *
       *               *
      * *             * *
     *   *           *   *
    * * * *         * * * *
   *       *       *       *
  * *     * *     * *     * *
 *   *   *   *   *   *   *   *
* * * * * * * * * * * * * * * *

Mandelbrot Set

ASCII visualization of the Mandelbrot set:

func mandelbrot(z, r=20) {
    var c = z
    r.times {
        z = (z*z + c)
        return true if (z.abs > 2)
    }
    return false
}

for y in (1 `downto` -1 `by` 0.05) {
    for x in (-2 `upto` 0.5 `by` 0.0315) {
        print(mandelbrot(Complex(x, y)) ? ' ' : '#')
    }
    print "\n"
}

                                                            #
                                                        #  ###  #
                                                        ########
                                                       #########
                                                         ######
                                             ##    ## ############  #
                                              ### ###################      #
                                              #############################
                                              ############################
                                          ################################
                                           ################################
                                         #################################### #
                          #     #        ###################################
                          ###########    ###################################
                           ###########   #####################################
                         ############## ####################################
                        ####################################################
                     ######################################################
#########################################################################
                     ######################################################
                        ####################################################
                         ############## ####################################
                           ###########   #####################################
                          ###########    ###################################
                          #     #        ###################################
                                         #################################### #
                                           ################################
                                          ################################
                                              ############################
                                              #############################
                                              ### ###################      #
                                             ##    ## ############  #
                                                         ######
                                                       #########
                                                        ########
                                                        #  ###  #
                                                            #

⚡ Performance

Although Sidef is a high-level language, its numerical core is powered by highly optimized native libraries including GMP, MPFR, MPC, and Math::Prime::Util::GMP. This allows computations with extremely large integers and high-precision arithmetic while keeping programs concise and expressive.

📚 Documentation & Learning Resources

Code Examples

🎨 Design Philosophy

Sidef combines expressive modern programming constructs with exact mathematics and symbolic computation. The language is designed to make advanced algorithms concise, readable, and practical while remaining fully interoperable with the Perl ecosystem.

💬 Community & Support

Have questions or need help? Join the conversation:

• Discussion Forum - Q&A and community discussions
• GitHub Issues - Bug reports and feature requests

📦 Distribution Availability

🤝 Contributing

Contributions of all kinds are welcome — bug reports, feature suggestions, documentation improvements, and pull requests. Please read CONTRIBUTING.md for guidelines on:

• Reporting bugs and suggesting features
• Setting up a development environment
• Code style and commit message conventions
• The pull request review process

📄 License and Copyright

Copyright © 2013-2026 Daniel Șuteu, Ioana Fălcușan

This program is free software; you can redistribute it and/or modify it under the terms of the Artistic License (2.0).

Full license: perlfoundation.org/artistic-license-20.html