** ** **** * ********* *********
* * ** * * **** ** ** ** ** ** ** **
** ** **** *** ********* * * *
** ** ** **** * * ****** ******
* * * * * * * * * **** ** ** ** ** ** **
** ** ** **** ****** ****** * *
** ** **** * * * ********* ***
* * ** * * **** ** ** ** ** ** ** **
** ** **** ********* ********* *
A modern, high-level programming language for versatile general-purpose applications
Website • Tutorial • Documentation • Try Online • Discussions
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]Sidef is an excellent choice for:
- Mathematical research and experimentation
- Number theory and cryptography
- Project Euler and competitive programming
- Symbolic computation and computer algebra
- Scientific computing
- Rapid scripting and automation
- Algorithm prototyping
- Perl developers seeking a higher-level language
| 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 | ✅ | ❌ | ❌ |
- 🔢 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
- Project Euler solutions
- OEIS research and experimentation
- Integer factorization and primality testing
- Cryptography and modular arithmetic
- Scientific scripting
- Algorithm prototyping
- General-purpose automation
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-devArch Linux:
sudo pacman -S gmp mpfr libmpcTermux:
pkg install perl make clang libgmp libmpfr libmpcVia CPAN:
cpan Sidef
# or (skip tests for faster install):
cpan -T Sidef
# or with cpanminus:
cpanm SidefBuild from source:
git clone https://github.com/trizen/sidef.git
cd sidef
perl Makefile.PL
make
make test
make installVia AUR:
trizen -S sidefPlatform packages:
- Arch Linux: AUR package
- Slackware: SlackBuilds
- Other systems: See pkgs.org
say "Hello, World!"sidef hello.sf
sidef -E 'say "Hello, World!"'
sidef -i # start the REPLExperiment with Sidef instantly at Try It Online without any installation.
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 } # Blockfunc 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) #=> 55class 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!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 totalsay 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# 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]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 filesStart 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 -Hclass 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# 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]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]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]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)Show Output
*
* *
* *
* * * *
* *
* * * *
* * * *
* * * * * * * *
* *
* * * *
* * * *
* * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *
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"
}Show Output
#
# ### #
########
#########
######
## ## ############ #
### ################### #
#############################
############################
################################
################################
#################################### #
# # ###################################
########### ###################################
########### #####################################
############## ####################################
####################################################
######################################################
#########################################################################
######################################################
####################################################
############## ####################################
########### #####################################
########### ###################################
# # ###################################
#################################### #
################################
################################
############################
#############################
### ################### #
## ## ############ #
######
#########
########
# ### #
#
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.
| 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 |
| 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 |
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.
Have questions or need help? Join the conversation:
- Discussion Forum - Q&A and community discussions
- GitHub Issues - Bug reports and feature requests
| Platform | Package | Link |
|---|---|---|
| CPAN | Sidef |
metacpan.org |
| Package Search | Multiple distributions | pkgs.org |
| Arch Linux | sidef (AUR) |
AUR Package |
| Slackware | perl-Sidef |
SlackBuilds.org |
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
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