The Sidef Programming Language
** ** **** * ********* *********
* * ** * * **** ** ** ** ** ** ** **
** ** **** *** ********* * * *
** ** ** **** * * ****** ******
* * * * * * * * * **** ** ** ** ** ** **
** ** ** **** ****** ****** * *
** ** **** * * * ********* ***
* * ** * * **** ** ** ** ** ** ** **
** ** **** ********* ********* *
A modern, high-level programming language for versatile general-purpose applications
Website • Tutorial • Documentation • Try Online • Discussions
🌟 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?
| Feature | Sidef | Python | Ruby | |---|:---:|:---:|:---:| | Exact rational arithmetic by default | ✅ | ❌ | ❌ | | Arbitrary-precision integers | ✅ | ✅ | ✅ | | Extensive built-in number theory | ✅ | ❌ | ❌ | | Computer algebra features | ✅ | ❌ | ❌ | | Multiple dispatch | ✅ | ❌ | Limited | | Perl interoperability | ✅ | ❌ | ❌ |
✨ 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:
| Library | Purpose | |---------|---------| | GMP | Big integers and rationals | | MPFR | Arbitrary-precision floats | | MPC | Arbitrary-precision complex numbers |
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]
| Flag | Description |
|------|-------------|
| -E 'code' | Execute a one-line program |
| -e 'code' | Alias for -E |
| -i [file] | Start the interactive REPL (optionally loading a file) |
| -c | Compile script to a stand-alone Perl program |
| -C | Check syntax only (parse without execution) |
| -r | Deparse program back to Sidef code |
| -R lang | Deparse to another language (perl, sidef) |
| -P int | Set floating-point precision in bits (default: 192) |
| -O level | Optimization level: 0 (none), 1 (recommended), 2 (max) |
| -s | Enable precompilation (cache compiled code) |
| -t | Test mode: treat all arguments as script files |
| -D | Dump the Abstract Syntax Tree (AST) |
| -H | Interactive help mode for exploring documentation |
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
| Resource | Description | |----------|-------------| | 📘 Sidef GitBook | The complete language reference — covers everything | | 📄 Beginner's Guide | Start here if you're new to Sidef | | 📝 Advanced Guide | Comprehensive language tutorial | | 📕 Full PDF Documentation | Offline PDF version of the complete language documentation | | 📑 Number Theory Cheatsheet | Quick reference for Sidef's number theory functions | | 📚 Number Theory Guide | Deep dive into Sidef's mathematical superpowers | | 🔢 Number Theory Reference | Complete function reference for number theory |
Code Examples
| Resource | Description | |----------|-------------| | 📂 sidef-scripts | Hundreds of real Sidef programs — the best way to learn by reading | | 🌹 RosettaCode — Sidef | Classic programming tasks solved in Sidef, side-by-side with other languages |
🎨 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
| Platform | Package | Link |
|----------|---------|------|
| CPAN | Sidef | metacpan.org |
| Package Search | Multiple distributions | pkgs.org |
| Arch Linux | sidef (AUR) | AUR Package |
| Slackware | perl-Sidef | SlackBuilds.org |
🤝 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
Made with ❤️ by the Sidef community