Crystal Programming Language Cheatsheet

Crystal is a statically-typed, compiled programming language with a syntax that resembles Ruby. It is designed to be efficient, expressive, and statically checked, making it an excellent choice for developers who appreciate the benefits of both static typing and a clean, concise syntax. Whether you’re a beginner getting started with Crystal or an experienced developer looking for a quick reference guide, this cheatsheet is here to help you navigate the essentials of the Crystal programming language.

Hello World

   puts "Hello, World!"

Variables and Constants

   # Variables
   name = "Crystal"
   age = 5

   # Constants
   VERSION = "1.0.0"

Data Types

   # Basic types
   number = 42
   float_number = 3.14
   is_true = true
   text = "Crystal is awesome!"

   # Arrays and Hashes
   numbers = [1, 2, 3, 4]
   person = {"name" => "Alice", "age" => 30}

Control Flow

   # If statement
   if condition
     # code to execute when condition is true
     # code to execute when condition is false

   # Case statement
   case variable
   when value1
     # code to execute when variable equals value1
   when value2
     # code to execute when variable equals value2
     # code to execute when none of the values match


   # While loop
   while condition
     # code to execute while condition is true

   # For loop
   for item in collection
     # code to execute for each item in the collection


   # Defining a function
   def greet(name : String) : String
     "Hello, #{name}!"

   # Calling a function
   message = greet("Bob")

Classes and Objects

   # Defining a class
   class Person
     property name : String
     property age : Int32

     def initialize(@name : String, @age : Int32)

     def greet
       "Hello, #{@name}!"

   # Creating an object
   person ="Alice", 30)
   puts person.greet

Exception Handling

     # code that might raise an exception
   rescue ex : SomeException
     # handle the exception of type SomeException
     # code to execute if no exception is raised
     # code that always executes, whether an exception is raised or not

Modules and Includes

   # Defining a module
   module MyModule
     def my_method
       "This is a method from MyModule"

   # Including a module in a class
   class MyClass
     include MyModule

   obj =
   puts obj.my_method


Crystal provides built-in support for lightweight concurrency with fibers. However, a detailed discussion of concurrency in Crystal is beyond the scope of this cheatsheet.


This cheatsheet covers the fundamental aspects of Crystal programming, providing a quick reference for common syntax and constructs. For more in-depth information, refer to the official Crystal documentation at

Crystal’s combination of speed, readability, and expressiveness makes it a compelling language for a wide range of applications. Whether you’re building web applications, scripting, or tackling system-level programming, Crystal offers a powerful and enjoyable development experience. Use this cheatsheet as a starting point to accelerate your Crystal programming journey!


1. What is Crystal, and how does it differ from other programming languages?

Crystal is a statically-typed, compiled programming language that shares syntax similarities with Ruby. One of its key differentiators is its performance, as it compiles to native code and aims to be as fast as languages like C and C++. Crystal also provides a clean and expressive syntax, making it more approachable for developers familiar with Ruby.

2. Is Crystal suitable for web development, and does it have a web framework?

Yes, Crystal is suitable for web development, and it has a popular web framework called Kemal. Kemal is inspired by the simplicity of Sinatra in the Ruby world and provides a fast and efficient way to build web applications. It includes features such as routing, middleware support, and templating.

3. How is error handling done in Crystal?

Crystal uses a combination of begin, rescue, else, and ensure blocks for error handling. Developers can enclose code that might raise exceptions within a begin block and handle specific exception types in rescue blocks. The else block contains code executed when no exception occurs, and the ensure block holds code that always executes, whether an exception is raised or not.

4. Can Crystal interface with existing C libraries?

Yes, Crystal has the ability to interface with existing C libraries. The language provides a Foreign Function Interface (FFI) that allows developers to call C functions directly from Crystal code. This feature is particularly useful when integrating Crystal into existing projects or leveraging well-established C libraries.

5. What is Crystal’s approach to concurrency, and does it support multi-threading?

Crystal leverages a concurrency model based on fibers, which are lightweight, cooperative threads. While Crystal does not provide native support for multi-threading in the traditional sense, developers can use fibers and the spawn keyword for concurrent execution. The language’s approach to concurrency is designed to be efficient and scalable, making it suitable for a variety of concurrent programming scenarios.