Crystal - Programming language

Crystal is an open source programming language created in 2014 by Ary Borenszweig and Juan Wajnerman and Brian Cardiff.

#53on PLDB

10Years Old

8kRepos

Download source code:

git clone https://github.com/crystal-lang/crystal

Homepage · REPL · Try It Online · Source Code · Blog · Wikipedia · Subreddit · Twitter · FAQ · Release Notes · Docs

In computer software programming languages, Crystal is a general-purpose, object-oriented programming language, designed and developed by Ary Borenszweig and Juan Wajnerman and more than 200 contributors. With syntax inspired by the language Ruby, it is a compiled language with static type-checking, but specifying the types of variables or method arguments is generally unneeded. Types are resolved by an advanced global type inference algorithm. Read more on Wikipedia...

Tags: programming language
Crystal is developed on GitHub and has 19,260 stars
Watch the history of the Crystal repo visualized with Gource
There are at least 7,522 Crystal repos on GitHub
Early development of Crystal happened in https://forum.crystal-lang.org/
Crystal is written in Crystal, Embedded Crystal, YAML, Markdown, HTML, JavaScript, PowerShell, Bourne shell, CSS, C, SVG, Make, XML, Python, JSON, Z shell, Bash, C++, Nix, Ini
The Google BigQuery Public Dataset GitHub snapshot shows 767 users using Crystal in 1k repos on GitHub
There are 4,118 members in the Crystal subreddit
There are 14 Project Euler users using Crystal
In the 2021 StackOverflow developer survey Crystal programmers reported a median salary of $72,400. 1% of respondents reported using Crystal. 466 programmers reported using Crystal, and 790 said they wanted to use it
Explore Crystal snippets on Rosetta Code
Crystal ranks #24 in the TIOBE Index
Crystal LSP implementation
Pygments supports syntax highlighting for Crystal
GitHub supports syntax highlighting for Crystal
Learn Crystal on exercism.
crystal-lang.org was registered in 2013
See also: (10 related languages) IA-32, FreeBSD, Ruby, C, Rust, Go, C#, Python, LLVM IR, CSP
8 PLDB concepts link to Crystal: Ace Editor, Civet, Crystal, Embedded Crystal, mal, Pegasus, Pygments, Savi

Example from Compiler Explorer:

# Type your code here, or load an example.

# compile with --prelude=empty
fun square(num : Int32) : Int32
  num &* num
end

Example from Riju:

puts "Hello, world!"

Example from hello-world:

puts "Hello World"

Example from the Hello World Collection:

# Hello world in Crystal

puts "Hello World"

Example from Linguist:

#!/usr/bin/env bin/crystal --run
require "../../spec_helper"

describe "Type inference: declare var" do
  it "types declare var" do
    assert_type("a :: Int32") { int32 }
  end

  it "types declare var and reads it" do
    assert_type("a :: Int32; a") { int32 }
  end

  it "types declare var and changes its type" do
    assert_type("a :: Int32; while 1 == 2; a = 'a'; end; a") { union_of(int32, char) }
  end

  it "declares instance var which appears in initialize" do
    result = assert_type("
      class Foo
        @x :: Int32
      end

      Foo.new") { types["Foo"] }

    mod = result.program

    foo = mod.types["Foo"] as NonGenericClassType
    foo.instance_vars["@x"].type.should eq(mod.int32)
  end

  it "declares instance var of generic class" do
    result = assert_type("
      class Foo(T)
        @x :: T
      end

      Foo(Int32).new") do
        foo = types["Foo"] as GenericClassType
        foo_i32 = foo.instantiate([int32] of Type | ASTNode)
        foo_i32.lookup_instance_var("@x").type.should eq(int32)
        foo_i32
    end
  end

  it "declares instance var of generic class after reopen" do
    result = assert_type("
      class Foo(T)
      end

      f = Foo(Int32).new

      class Foo(T)
        @x :: T
      end

      f") do
        foo = types["Foo"] as GenericClassType
        foo_i32 = foo.instantiate([int32] of Type | ASTNode)
        foo_i32.lookup_instance_var("@x").type.should eq(int32)
        foo_i32
    end
  end

  it "declares an instance variable in initialize" do
    assert_type("
      class Foo
        def initialize
          @x :: Int32
        end

        def x
          @x
        end
      end

      Foo.new.x
      ") { int32 }
  end
end

Example from Wikipedia:

channel = Channel(Int32).new

spawn do
  puts "Before first send"
  channel.send(1)
  puts "Before second send"
  channel.send(2)
end

puts "Before first receive"
value = channel.receive
puts value # => 1

puts "Before second receive"
value = channel.receive
puts value # => 2

Crystal Keywords

abstract do if nil? self unless alias else in of sizeof until as elsif include out struct when as? end instance_sizeof pointerof super while asm ensure is_a? private then with begin enum lib protected true yield break extend macro require type case false module rescue typeof class for next return uninitialized def fun nil select union

Language features

Feature	Supported	Example	Token
While Loops	✓
Conditionals	✓
Functions	✓
Classes	✓
File Imports	✓	require "../../spec_helper"	require
Booleans	✓		true false
Strings	✓	"Hello world"	"
Print() Debugging	✓		puts
Comments	✓	# A comment
Line Comments	✓	# A comment	#
Type Inference	✓
Semantic Indentation	X
MultiLine Comments	X