29 Premium Themes
Included with purchase — and more features on the way!
Get access — $12 once
Version 2 is coming soon.
The price goes up when it arrives.
Pay once today and every update after that is free.
One Dark Pro
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Andromeda
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Ayu Dark
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Ayu Mirage
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Ayu Light
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Cobalt2
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Night Owl
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Night Owl Light
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Azureus
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Bordo
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Hibernus
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Lilac
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Lux
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Minimus
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Obscuro
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Sereno
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Uva
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Noctis Viola
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Palenight
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Pico 8
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Shades of Purple
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Shades of Purple SD
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Synthwave '84
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Tokyo Night
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Tokyo Night Storm
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Tokyo Night Light
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Winter is Coming
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Winter is Coming Light
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v
Winter is Coming Dark
// This program displays the fibonacci sequence
import os
fn main() {
// Check for user input
if os.args.len != 2 {
println('usage: fibonacci [rank]')
return
}
// Parse first argument and cast it to int
stop := os.args[1].int()
// Can only calculate correctly until rank 92
if stop > 92 {
println('rank must be 92 or less')
return
}
// Three consecutive terms of the sequence
mut a := i64(0)
mut b := i64(0)
mut c := i64(1)
println(a + b + c)
for _ in 0 .. stop {
// Set a and b to the next term
a = b
b = c
// Compute the new term
c = a + b
// Print the new term
println(c)
}
}
// From https://github.com/vlang/v/blob/master/examples/fibonacci.v