Base16 color scheme previews

Click the code previews to expand

3024 by Jan T. Sott (http://github.com/idleberg)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Albino bark on a tree by Gabriel Arazas (https://foodogsquared.one)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Ancient One Dark by holodata

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Apathy by Jannik Siebert (https://github.com/janniks)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Apprentice by romainl

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Ashes by Jannik Siebert (https://github.com/janniks)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Cave by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Cave Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Dune by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Dune Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Estuary by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Estuary Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Forest by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Forest Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Heath by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Heath Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Lakeside by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Lakeside Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Plateau by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Plateau Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Savanna by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Savanna Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Seaside by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Seaside Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Sulphurpool by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atelier Sulphurpool Light by Bram de Haan (http://atelierbramdehaan.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Atlas by Alex Lende (https://ajlende.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Ayu Dark by Khue Nguyen <Z5483Y@gmail.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Ayu Light by Khue Nguyen <Z5483Y@gmail.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Ayu Mirage by Khue Nguyen <Z5483Y@gmail.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Bark on a tree by Gabriel Arazas (https://foodogsquared.one)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Bespin by Jan T. Sott

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Bathory) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Burzum) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Dark Funeral) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Gorgoroth) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Immortal) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Khold) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Marduk) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Mayhem) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Nile) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Black Metal (Venom) by metalelf0 (https://github.com/metalelf0)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Blue Forest by alonsodomin (https://github.com/alonsodomin)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Blueish by Ben Mayoras

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Brewer by Timothée Poisot (http://github.com/tpoisot)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Bright by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Brogrammer by Vik Ramanujam (http://github.com/piggyslasher)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Brush Trees Dark by Abraham White <abelincoln.white@gmail.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Brush Trees by Abraham White <abelincoln.white@gmail.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

caroline by ed (https://codeberg.org/ed)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Catppuccin Frappe by https://github.com/catppuccin/catppuccin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Catppuccin Latte by https://github.com/catppuccin/catppuccin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Catppuccin Macchiato by https://github.com/catppuccin/catppuccin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Catppuccin Mocha by https://github.com/catppuccin/catppuccin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Chalk by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

chameleon by japanoise (https://github.com/japanoise)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Circus by Stephan Boyer (https://github.com/stepchowfun) and Esther Wang (https://github.com/ewang12)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

City lights by Yummygum (https://yummygum.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Classic Dark by Jason Heeris (http://heeris.id.au)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Classic Light by Jason Heeris (http://heeris.id.au)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Codeschool by blockloop

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Colors by mrmrs (http://clrs.cc)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Cupcake by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Cupertino by Defman21

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

DanQing by Wenhan Zhu (Cosmos) (zhuwenhan950913@gmail.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

DanQing Light by Wenhan Zhu (Cosmos) (zhuwenhan950913@gmail.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Da One Black by NNB (https://github.com/NNBnh)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Da One Gray by NNB (https://github.com/NNBnh)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Da One Ocean by NNB (https://github.com/NNBnh)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Da One Paper by NNB (https://github.com/NNBnh)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Da One Sea by NNB (https://github.com/NNBnh)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Da One White by NNB (https://github.com/NNBnh)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Darcula by jetbrains

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

darkmoss by Gabriel Avanzi (https://github.com/avanzzzi)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Darktooth by Jason Milkins (https://github.com/jasonm23)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Dark Violet by ruler501 (https://github.com/ruler501/base16-darkviolet)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Decaf by Alex Mirrington (https://github.com/alexmirrington)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Default Dark by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Default Light by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

dirtysea by Kahlil (Kal) Hodgson

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Dracula by Mike Barkmin (http://github.com/mikebarkmin) based on Dracula Theme (http://github.com/dracula)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Edge Dark by cjayross (https://github.com/cjayross)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Edge Light by cjayross (https://github.com/cjayross)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Eighties by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Embers by Jannik Siebert (https://github.com/janniks)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

emil by limelier

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Equilibrium Dark by Carlo Abelli

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Equilibrium Gray Dark by Carlo Abelli

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Equilibrium Gray Light by Carlo Abelli

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Equilibrium Light by Carlo Abelli

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

eris by ed (https://codeberg.org/ed)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Espresso by Unknown. Maintained by Alex Mirrington (https://github.com/alexmirrington)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Eva Dim by kjakapat (https://github.com/kjakapat)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Eva by kjakapat (https://github.com/kjakapat)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Evenok Dark by Mekeor Melire

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Everforest Dark Hard by Oskar Liew (https://github.com/OskarLiew)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Everforest by Sainnhe Park (https://github.com/sainnhe)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Felinoid by Emma Eilefsen Glenna (http://eilefsen.net)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Flat by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Forest and Stream Dark by Xavier Tilley (hippietilley)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Framer by Framer (Maintained by Jesse Hoyos)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Catppuccin Frappe by https://github.com/catppuccin/catppuccin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Fruit Soda by jozip

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gigavolt by Aidan Swope (http://github.com/Whillikers)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Github by Defman21

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Google Dark by Seth Wright (http://sethawright.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Google Light by Seth Wright (http://sethawright.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gotham by Andrea Leopardi (arranged by Brett Jones)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Grayscale Dark by Alexandre Gavioli (https://github.com/Alexx2/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Grayscale Light by Alexandre Gavioli (https://github.com/Alexx2/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Green Screen by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruber by Patel, Nimai <nimai.m.patel@gmail.com>, colors from www.github.com/rexim/gruber-darker-theme

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox dark, baby by Ali Elwnegy (alinwegy@gmail.com), Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox dark, hard by Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox dark, medium by Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox dark, pale by Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox dark, soft by Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox light, baby by Ali Elnwegy (alinwegy@gmail.com), Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox light, hard by Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox light, medium by Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox light, soft by Dawid Kurek (dawikur@gmail.com), morhetz (https://github.com/morhetz/gruvbox)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox Material Dark, Hard by Mayush Kumar (https://github.com/MayushKumar), sainnhe (https://github.com/sainnhe/gruvbox-material-vscode)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox Material Dark, Medium by Mayush Kumar (https://github.com/MayushKumar), sainnhe (https://github.com/sainnhe/gruvbox-material-vscode)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox Material Dark, Soft by Mayush Kumar (https://github.com/MayushKumar), sainnhe (https://github.com/sainnhe/gruvbox-material-vscode)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox Material Light, Hard by Mayush Kumar (https://github.com/MayushKumar), sainnhe (https://github.com/sainnhe/gruvbox-material-vscode)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox Material Light, Medium by Mayush Kumar (https://github.com/MayushKumar), sainnhe (https://github.com/sainnhe/gruvbox-material-vscode)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Gruvbox Material Light, Soft by Mayush Kumar (https://github.com/MayushKumar), sainnhe (https://github.com/sainnhe/gruvbox-material-vscode)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Hardcore by Chris Caller

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Harmonic16 Dark by Jannik Siebert (https://github.com/janniks)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Harmonic16 Light by Jannik Siebert (https://github.com/janniks)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Harmonic16 Dark by Jannik Siebert (https://github.com/janniks)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Harmonic16 Light by Jannik Siebert (https://github.com/janniks)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Heetch Dark by Geoffrey Teale (tealeg@gmail.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Heetch Light by Geoffrey Teale (tealeg@gmail.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Helios by Alex Meyer (https://github.com/reyemxela)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Hopscotch by Jan T. Sott

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Horizon Dark by Michaël Ball (http://github.com/michael-ball/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Horizon Light by Michaël Ball (http://github.com/michael-ball/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Horizon Dark by Michaël Ball (http://github.com/michael-ball/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

details> Horizon Light by Michaël Ball (http://github.com/michael-ball/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

details> Humanoid dark by Thomas (tasmo) Friese

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Humanoid light by Thomas (tasmo) Friese

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

iA Dark by iA Inc. (modified by aramisgithub)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

iA Light by iA Inc. (modified by aramisgithub)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Icy Dark by icyphox (https://icyphox.ga)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

IR Black by Timothée Poisot (http://timotheepoisot.fr)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Isotope by Jan T. Sott

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Jardo Brighter by Jared Norman (https://jardo.dev)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Jellybeans by Max van Deurzen (https://github.com/deurzen)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Kanagawa by Tommaso Laurenzi (https://github.com/rebelot)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Katy by George Essig (https://github.com/gessig)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Kimber by Mishka Nguyen (https://github.com/akhsiM)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Catppuccin Latte by https://github.com/catppuccin/catppuccin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

lime by limelier

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Catppuccin Macchiato by https://github.com/catppuccin/catppuccin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Macintosh by Rebecca Bettencourt (http://www.kreativekorp.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Marrakesh by Alexandre Gavioli (http://github.com/Alexx2/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Materia by Defman21

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Material Darker by Nate Peterson

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Material by Nate Peterson

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Material Lighter by Nate Peterson

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Material Palenight by Nate Peterson

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Material Vivid by joshyrobot

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Measured Dark by Measured (https://measured.co)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Measured Light by Measured (https://measured.co)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Mellow Purple by gidsi

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Mexico Light by Sheldon Johnson

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Catppuccin Mocha by https://github.com/catppuccin/catppuccin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Monokai by Wimer Hazenberg (http://www.monokai.nl)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Moonlight by Jeremy Swinarton (https://swinarton.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Mountain by gnsfujiwara (https://github.com/gnsfujiwara)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Nebula by Gabriel Fontes (https://github.com/Misterio77)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

nono-dark by elmotec

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

nono-light by elmotec

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Nord by arcticicestudio

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Nova by George Essig (https://github.com/gessig), Trevor D. Miller (https://trevordmiller.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Ocean by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

OceanicNext by https://github.com/voronianski/oceanic-next-color-scheme

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

OneDark by Lalit Magant (http://github.com/tilal6991)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

One Light by Daniel Pfeifer (http://github.com/purpleKarrot)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Outrun Dark by Hugo Delahousse (http://github.com/hugodelahousse/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Oxocarbon Dark by shaunsingh/IBM

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Oxocarbon Light by shaunsingh/IBM

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

pandora by Cassandra Fox

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

PaperColor Dark by Jon Leopard (http://github.com/jonleopard) based on PaperColor Theme (https://github.com/NLKNguyen/papercolor-theme)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

PaperColor Light by Jon Leopard (http://github.com/jonleopard) based on PaperColor Theme (https://github.com/NLKNguyen/papercolor-theme)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Paraiso by Jan T. Sott

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Pasque by Gabriel Fontes (https://github.com/Misterio77)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

PhD by Hennig Hasemann (http://leetless.de/vim.html)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Pico by PICO-8 (http://www.lexaloffle.com/pico-8.php)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

pinky by Benjamin (https://github.com/b3nj5m1n)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Pop by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Porple by Niek den Breeje (https://github.com/AuditeMarlow)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Precious Dark Eleven by 4lex4 <4lex49@zoho.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Precious Dark Fifteen by 4lex4 <4lex49@zoho.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Precious Light Warm by 4lex4 <4lex49@zoho.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Precious Light White by 4lex4 <4lex49@zoho.com>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Primer Dark Colorblind by Jimmy Lin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Primer Dark Dimmed by Jimmy Lin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Primer Dark High Contrast by Jimmy Lin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Primer Dark by Jimmy Lin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Primer Light Colorblind by Jimmy Lin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Primer Light by Jimmy Lin

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Purpledream by malet

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Qualia by isaacwhanson

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Railscasts by Ryan Bates (http://railscasts.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Rebecca by Victor Borja (http://github.com/vic) based on Rebecca Theme (http://github.com/vic/rebecca-theme)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Rigel by Alexander Keliris

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Rosé Pine Dawn by Emilia Dunfelt <edun@dunfelt.se>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Rosé Pine by Emilia Dunfelt <edun@dunfelt.se>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Rosé Pine Moon by Emilia Dunfelt <edun@dunfelt.se>

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Sagelight by Carter Veldhuizen

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Sakura by Misterio77 (http://github.com/Misterio77)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Sandcastle by George Essig (https://github.com/gessig)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

selenized-black by Jan Warchol (https://github.com/jan-warchol/selenized) / adapted to base16 by ali

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

selenized-dark by Jan Warchol (https://github.com/jan-warchol/selenized) / adapted to base16 by ali

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

selenized-light by Jan Warchol (https://github.com/jan-warchol/selenized) / adapted to base16 by ali

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

selenized-white by Jan Warchol (https://github.com/jan-warchol/selenized) / adapted to base16 by ali

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Seti UI by

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

ShadeSmear Dark by Kyle Giammarco (http://kyle.giammar.co)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

ShadeSmear Light by Kyle Giammarco (http://kyle.giammar.co)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Shades of Purple by Iolar Demartini Junior (http://github.com/demartini) based on Shades of Purple Theme (https://github.com/ahmadawais/shades-of-purple-vscode).

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Shapeshifter by Tyler Benziger (http://tybenz.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Silk Dark by Gabriel Fontes (https://github.com/Misterio77)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Silk Light by Gabriel Fontes (https://github.com/Misterio77)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Snazzy by Chawye Hsu (https://github.com/chawyehsu) based on Hyper Snazzy Theme (https://github.com/sindresorhus/hyper-snazzy)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Solar Flare by Chuck Harmston (https://chuck.harmston.ch)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Solar Flare Light by Chuck Harmston (https://chuck.harmston.ch)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Solarized Dark by Ethan Schoonover (modified by aramisgithub)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Solarized Light by Ethan Schoonover (modified by aramisgithub)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Solarnz by Chris Kempson (http://chriskempson.com) Modified by Chris Trotman

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Spaceduck by Guillermo Rodriguez (https://github.com/pineapplegiant), packaged by Gabriel Fontes (https://github.com/Misterio77)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Spacemacs by Nasser Alshammari (https://github.com/nashamri/spacemacs-theme)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

srcery by

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

standardized-dark by ali (https://github.com/ali-githb/base16-standardized-scheme)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

standardized-light by ali (https://github.com/ali-githb/base16-standardized-scheme)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Stella by Shrimpram

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Still Alive by Derrick McKee (derrick@geth.systems)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

s> summercamp by zoe firi (zoefiri.github.io)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Summerfruit Dark by Christopher Corley (http://christop.club/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Summerfruit Light by Christopher Corley (http://christop.club/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Synth Midnight Terminal Dark by Michaël Ball (http://github.com/michael-ball/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Synth Midnight Terminal Light by Michaël Ball (http://github.com/michael-ball/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tango by @Schnouki, based on the Tango Desktop Project

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

tarot by ed (https://codeberg.org/ed)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

tender by Jacobo Tabernero (https://github/com/jacoborus/tender.vim)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Terracotta Dark by Alexander Rossell Hayes (alexander@rossellhayes.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Terracotta by Alexander Rossell Hayes (alexander@rossellhayes.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo City Dark by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo City Light by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo City Terminal Dark by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo City Terminal Light by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyodark by Tiagovla (https://github.com/tiagovla/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyodark Terminal by Tiagovla (https://github.com/tiagovla/)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo Night Dark by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo Night Light by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo Night Storm by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo Night Terminal Dark by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo Night Terminal Light by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tokyo Night Terminal Storm by Michaël Ball

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tomorrow by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tomorrow Night Eighties by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tomorrow Night by Chris Kempson (http://chriskempson.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

London Tube by Jan T. Sott

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Tucson by Kopsis

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Twilight by David Hart (https://github.com/hartbit)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Unikitty Dark by Josh W Lewis (@joshwlewis)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Unikitty Light by Josh W Lewis (@joshwlewis)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Unikitty Reversible by Josh W Lewis (@joshwlewis)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Unified Platform by tmiller@mitre.org

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

UwUnicorn by Fernando Marques (https://github.com/RakkiUwU) and Gabriel Fontes (https://github.com/Misterio77)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Vice Alt by Thomas Leon Highbaugh

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Vice Dark by Thomas Leon Highbaugh

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

r/> Void Bear by kvoli (https://github.com/kvoli)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

vulcan by Andrey Varfolomeev

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Windows 10 by Fergus Collins (https://github.com/C-Fergus)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Windows 10 Light by Fergus Collins (https://github.com/C-Fergus)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Windows 95 by Fergus Collins (https://github.com/C-Fergus)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Windows 95 Light by Fergus Collins (https://github.com/C-Fergus)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Windows High Contrast by Fergus Collins (https://github.com/C-Fergus)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Windows High Contrast Light by Fergus Collins (https://github.com/C-Fergus)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Windows NT by Fergus Collins (https://github.com/C-Fergus)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Windows NT Light by Fergus Collins (https://github.com/C-Fergus)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Woodland by Jay Cornwall (https://jcornwall.com)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

XCode Dusk by Elsa Gonsiorowski (https://github.com/gonsie)

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Zenbones by mcchrish

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"

Zenburn by elnawe

require "gem"; var = /[abc]/; class Person; initialize(attributes = {})

require "gem"

string = "base16"
symbol = :base16
fixnum = 0
float  = 0.00
array  = Array.new
array  = ['chris', 85]
hash   = {"test" => "test"}
regexp = /[abc]/

# This is a comment
class Person
  attr_accessor :name
  def initialize(attributes = {})
    @name = attributes[:name]
  end
  def self.greet
    "hello"
  end
end

person1 = Person.new(:name => "Chris")
print Person::greet, " ", person1.name, "\n"
puts "another #{Person::greet} #{person1.name}"