crystal-lang/crystal

Features

• Binary Compilation Toolchains - Compiles source code into efficient, statically linked machine-executable binaries for high-performance deployment.
• High-Performance Systems Programming - Enables high-performance systems programming with manual memory management and direct hardware-level access.
• Statically Typed Languages - A statically typed, compiled programming language designed for high performance and memory safety.
• Source Code Compilers - Transforms source code into optimized machine-code executables or runs them directly for rapid development.
• Compile-Time Metadata Inspection - Crystal accesses compile-time information about classes, modules, constants, and method definitions to drive conditional code generation.
• Native Binary Toolchains - Provides native binary toolchains for building standalone executables with support for optimization and static linking.
• High-Concurrency Networking - Builds scalable network services using lightweight fibers and asynchronous I/O for high-concurrency handling.
• Compilers - Uses an LLVM-based compiler infrastructure to translate high-level source code into optimized machine code.
• Concurrency Models - Provides a lightweight fiber-based concurrency model for managing asynchronous tasks without manual thread management.
• Pattern Matching - Evaluates an expression against multiple conditions using a subsumption operator to execute specific code blocks.
• Compile-Time Type Inference - Performs compile-time type inference to ensure type safety across dynamic operations.
• Foreign Function Interfaces - Provides a native foreign function interface for direct, high-performance interaction with external system libraries.
• Native C Interoperability - Facilitates direct interaction with native C libraries and data structures for performance-critical tasks.
• Nil-Check Narrowing - Enforces type safety by narrowing variable types through compile-time null check analysis.
• Type-Safe Development - Ensures robust software development through strict compile-time type checking and automated inference.
• Software Testing - Provides comprehensive automated testing and continuous integration workflows to verify code correctness.
• Null Value Representations - Determines whether an expression evaluates to a null type at runtime and updates type information for subsequent code blocks.
• AST Node Interpolation - Injects identifiers and expressions directly into generated code blocks using specialized syntax.
• Static Binaries - Transforms source code into standalone, self-contained executable files to simplify deployment.
• Thread-Safe Communication Channels - Enables safe data passing between concurrent fibers using communication channels.
• Compiled Binaries - Packages applications into standalone, statically linked binaries to simplify distribution across platforms.
• Character Encoding Utilities - Provides built-in support for 32-bit Unicode code points as character values.
• Control Flow - Executes specific code blocks based on conditional truthiness and performs type narrowing for compile-time safety.
• Metaprogramming & Macros - Enables compile-time code generation and AST transformation through a macro-based metaprogramming system.
• Method-Response Narrowing - Restricts variable types within conditional branches by verifying method availability for safe access.
• Type Safety - Enforces strict type safety by requiring explicit data types for method parameters.
• Explicit Variable Typing - Requires explicit type declarations for instance and class variables to ensure code readability and enable compiler optimizations.
• Primitive Data Literals - Provides built-in literal syntax for defining basic data types like booleans, numbers, and strings.
• Event Loop Concurrency - Manages lightweight execution units using an event loop for non-blocking asynchronous input and output.
• Safe Access Methods - Provides explicit question-mark methods to safely access collection elements or object states that may return nil.
• Cleanup Execution Patterns - Ensures specific code runs after a block finishes, regardless of whether an exception was raised, to manage resource disposal.
• Compile-Time Code Generation - Provides a powerful macro system that manipulates the abstract syntax tree to generate code dynamically during compilation.
• Concurrent Task Runners - Manages lightweight threads to perform simultaneous operations efficiently.
• Structures - Executes specific code blocks based on the truthiness of expressions, allowing for branching program flow.
• Exception Handling Strategies - Implements structured exception handling to manage runtime errors and ensure application stability.
• Generic Type Definitions - Supports generic type definitions to create reusable, type-safe components.
• Performance Optimization - Applies compiler-level techniques and static linking to optimize binary size and execution speed.
• Compile-Time Metaprogramming - Features a powerful compile-time macro system for AST inspection and dynamic code generation.
• Testing Frameworks - Provides a built-in testing framework to verify application logic and ensure code reliability.
• HTTP Request Handling - Listens for incoming network connections and executes custom logic to generate responses for each request.
• Loop Interruption Patterns - Skips the remainder of a current loop iteration or terminates the entire loop prematurely.
• Learning Resources - Catalog of Ruby gem equivalents for the language.
• Enumeration Types - Provides enumerated types with support for custom underlying integer types and automatic incrementing.
• Connection Pool Managers - Manages connection pools to handle concurrent database requests efficiently.
• Database Transactions - Groups multiple database operations into atomic units that commit or roll back to ensure data consistency.
• Multi-Target Build Orchestrators - Automates project target building by verifying dependencies and delegating configurations to the compiler.
• Dependency Lock Managers - Maintains version consistency through lock files to ensure reproducible builds across different environments.
• I/O Interfaces - Delegates I/O operations to an event loop for non-blocking asynchronous execution.
• Memory Allocation Libraries - Reclaims memory during program execution using a conservative garbage collector to handle allocation and cleanup tasks.
• Code Block Execution - Facilitates flexible logic injection and the creation of readable domain-specific languages.
• Type Definitions - Supports sophisticated type definitions including unions, tuples, and pointers for strict data modeling.
• Type Narrowing - Narrows the inferred type of a variable within conditional branches based on runtime type checks to ensure type safety.
• C Function Bindings - Maps native C functions to language methods within library definitions to execute compiled code directly from external libraries.
• Type Checking Disciplines - Validates objects against included modules to enable polymorphic behavior and type-safe collection handling.
• Generic Function Definitions - Creates executable function objects that capture local context and support explicit type definitions.
• Network Security - Implements TLS protocols and cryptographic routines to ensure secure network data transmission.
• Short-Circuit Operators - Provides short-circuit evaluation logic to optimize conditional expression execution.
• Code Generators - Leverages LLVM to translate source code into optimized machine-executable binaries.
• Iterative Loop Constructs - Iterates through blocks of code repeatedly based on truthy conditions to automate task repetition.
• Conditional Branching - Executes specific blocks of code only when defined conditions are met, supporting both positive and negative logic gates.
• Conditional Compilation Utilities - Supports conditional compilation to manage features and target environments using build-time flags.
• Conditional Iteration - Repeats a block of code as long as a specified condition remains true, with automatic type narrowing.
• Until Loop Structures - Repeats a block of code until a specified condition becomes true.
• Loop Termination Mechanisms - Exits the innermost active loop immediately and optionally returns a specified value.
• Execution Flow Control - Directs the flow of logic using conditional branching and iterative loops to manage complex application behavior.
• Loop Iteration Skipping Mechanisms - Interrupts the current execution cycle of a loop to immediately re-evaluate the loop condition.
• Return Type Annotations - Enforces type safety and improves documentation through explicit method return type annotations.
• Test Execution Runners - Compiles and executes spec files with support for various output formats and granular control.
• Database Connectivity Drivers - Provides a unified interface and drivers for connecting to various database engines.
• Range Definitions - Defines inclusive or exclusive intervals between values for sequence generation.
• Index-Based Accessors - Enables custom types to support bracket-based indexing for safe element retrieval and assignment.
• Data Serialization and Parsing - Provides libraries for parsing and emitting structured data formats like XML and YAML.
• Fixed-Size Collections - Groups heterogeneous elements into fixed-size, immutable structures that preserve individual type information.
• Structured Collection Definitions - Groups heterogeneous values into immutable collections with key-based access and type safety.
• Data Type Casting - Provides explicit object type casting to ensure safe access to type-specific methods.
• Safe Casting - Attempts to cast an object to a specific type and returns nil instead of raising an error if the conversion is not possible.
• Numeric Type Promotions - Automatically promotes numeric values to larger types to preserve precision during operations.
• Nested Transactions - Allows defining sub-transactions that share connections and inherit parent lifecycle states.
• Hash Data Structures - Groups multiple values into structured containers like arrays and hashes using concise literal syntax.
• Key-Value Stores - Creates associative mappings between keys and values using literal syntax for efficient storage.
• Loop Return Value Capture - Captures the result of a loop by returning the value provided to a break statement.
• Prepared Statements - Improves performance and security by pre-compiling SQL queries for repeated execution with parameters.
• Splat Unpacking - Expands collections into tuple structures using splat operators for flexible data handling.
• API Documentation Generators - Automatically generates structured API documentation websites from source code and comments.
• Compilation Flags - Allows defining custom compilation flags to toggle features and debugging modes during the build process.
• Dependency Bundling - Bundles required dependencies directly into the final executable to ensure portability.
• IDE Integrations - Connects the language toolchain to code editors to provide syntax highlighting, completion, and real-time error checking.
• External Command Executors - Invokes system shell commands and captures their output directly using specialized command literal syntax.
• Dynamic Type Systems - Applies dynamic type constraints to method arguments and variables to control input behavior.
• Low-Level System Operations - Provides direct access to raw memory and external C libraries for high-performance systems programming.
• Cross-Compilation Toolchains - Generates binaries for specific target platforms by specifying target triples during the build process.
• Block Signature Restrictions - Ensures type safety for code blocks passed as arguments.
• Class Method Definitions - Supports defining class-level methods that operate independently of specific object instances.
• Class Hierarchies - Provides standard object-oriented class hierarchy support for code organization.
• Code Block Captures - Enables storing code blocks as callbacks for later execution.
• Code Definition Namespaces - Organizes code structure and prevents naming conflicts.
• Immutable Constant Definitions - Supports defining immutable constants to ensure fixed values throughout program execution.
• Method Definitions - Enables defining multiple versions of a method with the same name to handle varied input types and counts.
• Argument Type Restrictors - Enforces type safety on method arguments to enable specific method overloads.
• Operator Overloading - Implements unary and binary operators as methods on custom types to define intuitive syntax.
• Type-Based Overloading - Creates method variants that accept specific types or class objects as arguments, allowing logic to branch based on the provided type.
• External Library Integrations - Links native code written in other languages directly into the application to leverage existing system-level functionality.
• Native Library Interfacing - Calls functions written in other languages directly from the source code to leverage existing system-level libraries.
• Program Entry Points - Runs top-level expressions sequentially upon startup without requiring a dedicated entry point method.
• Testing DSLs - Uses a domain-specific language to describe expected behavior through assertions and matchers.
• Garbage Collectors - Implements a conservative garbage collector that automatically reclaims memory by scanning heap and stack objects.
• Source Code Modularization - Improves maintainability by splitting logic across multiple files.
• Arbitrary Precision Arithmetic - Supports high-precision integer and rational number calculations through specialized mathematical libraries.
• Dynamic Method Generation - Creates methods for class hierarchies that automatically adapt their implementation based on the specific concrete subtype during compilation.
• Conditional Expression Returns - Evaluates conditional branches as expressions that return the result of the last statement executed.
• Conditional Expression Modifiers - Appends a conditional check to an expression to execute it only when the condition evaluates to true.
• Error Handling - Offers non-raising method variants that return null values instead of exceptions for lightweight error handling.
• Negative Conditional Logic - Runs specific code blocks based on the inverse truth value of a condition.
• Application Performance Optimization - Refines code execution paths to reduce memory footprint and latency for high-speed processing.
• Type Systems - Forces explicit type restrictions on expressions with runtime checks to ensure type safety.
• Character Encoding Support - Crystal supports international character sets, emojis, and icons within strings, including the ability to define specific codepoints using hexadecimal escape sequences.
• Pattern Literals - Constructs regular expression patterns using dedicated literal syntax for string matching.
• Ternary Expression Evaluators - Returns one of two values based on a boolean condition, providing a concise alternative to standard conditional blocks.
• Literal - Instantiates array-like types using concise literal syntax for automatic element assignment.
• Database Connectivity - Provides a unified interface for connecting to various relational database engines using connection URI strings.
• Database Query Execution - Retrieves database result sets with support for row iteration and explicit type casting.
• Enum Definitions - Allows defining custom logic and behavior directly within enum definitions.
• Literal Hash Initializers - Populates custom hash-like collections using concise literal syntax for constructor and element assignment.
• Ordered Collection Literals - Generates integer-indexed collections using shorthand percent notation.
• Raw SQL Execution - Executes SQL commands against databases with support for parameterized inputs to prevent injection vulnerabilities.
• String Array Literals - Initializes arrays of strings using whitespace-separated percent literals to avoid repetitive quoting.
• Tuple Merging - Combines tuples of matching structure into a single type containing the union of their elements.
• Compile-Time Capability Checks - Checks whether a specific type implements a given method at compile time to allow for conditional logic.
• Codebase Analysis Tools - Performs static analysis of type hierarchies and dependency trees to identify unreachable code and architectural issues.
• Automated Test Execution - Includes a comprehensive suite of automated testing frameworks to ensure code correctness.
• Dependency Installers - Manages external project libraries and system-level binary packages required for building and testing.
• Flag Definitions - Configures enumerations to behave as bitwise flags for specialized representation and string conversion.
• Action Concurrency - Coordinates concurrent operations by monitoring multiple tasks and managing cancellation.
• Build Caches - Persists dependency files and build outputs across pipeline runs to reduce total execution time.
• Container Image Packaging - Bundles compiled binaries into container images for portable execution and optimized deployment.
• Code Execution Runtimes - Runs code directly from the file scope without requiring a main function or entry point definition.
• Inline Assembly Interfaces - Allows embedding machine instructions directly into source code for performance-critical hardware operations.
• Stack Allocation Optimizations - Reduces garbage collection pressure by using stack-allocated structures instead of heap-allocated classes for temporary data.
• Bare Metal Development - Enables development for embedded systems by disabling the standard library and providing direct hardware access.
• Block Execution Controls - Provides precise flow control within yielded code blocks.
• Block Forwarding - Provides language-level support for passing and delegating code blocks between methods.
• Block Parameter Unpacking - Simplifies access to nested or multi-value data within code blocks.
• Block Receiver Modification - Enables changing the execution scope of code blocks for cleaner DSLs.
• Block Value Returns - Allows blocks to return values directly to the calling method.
• Custom Constructors - Enables custom object initialization logic through specialized class methods.
• Accessor Generators - Automates the creation of property accessors using compile-time macros.
• Regular Expression Engines - Integrates high-performance engines for regular expression pattern matching.
• Compiler Optimization Controls - Crystal directs the compiler to force or prevent the inlining of specific methods to balance execution speed against the final binary size.
• Expression-Oriented Evaluation - Returns the first truthy value from expressions, effectively combining types into a union.
• Global Scope Feature Definitions - Makes types and methods accessible throughout the application namespace.
• Thread Local Storage - Restricts variables to specific threads to ensure data safety and prevent conflicts during concurrent execution.
• Method Extensions - Provides language-level support for extending and wrapping existing method implementations.
• Function Invocation Mechanics - Executes stored function pointers by calling them with the required number and type of arguments.
• Hygienic Macro Systems - Crystal creates temporary variables within macro expansions that are guaranteed to avoid naming conflicts with existing local variables in the surrounding scope.
• Type Aliasing - Assigns alternative names to complex or lengthy types to improve code readability and enable recursive data structures.
• Explicit Type Guidance - Explicitly defines the expected type of an expression or block result when the compiler cannot automatically determine the correct type.
• Local Variable Declarations - Enables local variable definition with automatic type inference based on usage.
• External Library Linking - Groups external functions and types while providing attributes to configure linker flags, package discovery, and framework dependencies.
• Data Structure Mappings - Defines memory-compatible data structures that interface with external libraries.
• Method Visibility Controls - Limits method access to specific class hierarchies or namespaces to enforce encapsulation.
• Floating-Point Types - Defines decimal values using IEEE binary32 or binary64 formats with support for scientific notation.
• Struct Generators - Automates the creation of struct types with built-in initializers and cloning methods.
• Reusable Procedure Definitions - Encapsulates sequences of operations into named methods that accept typed arguments.
• Abstract Classes - Prevents instantiation of base classes and enforces method implementation in subclasses.
• Inheritance Checks - Checks whether an object's runtime type inherits from or includes a specified type to enable conditional logic.
• Symbol Array Literals - Generates arrays of unique identifiers using shorthand syntax that handles whitespace and delimiters.
• Type Visibility Controls - Crystal limits the scope of classes, modules, and constants to their defining namespace or file to prevent external access and accidental coupling.
• Variable Assignments - Provides standard syntax for updating variables, instance fields, and class members.
• Functional Programming Methods - Wraps existing methods or method-receiver pairs into callable objects for functional programming patterns.
• Object-Oriented Programming - Encapsulates data and state within objects to ensure consistent interaction patterns across the codebase.
• Bitwise Flag Definitions - Allows defining sets of constants as bitwise flags for efficient state management.
• Compile-Time Hooks - Triggers custom code during compilation when specific events occur, such as class inheritance or method definition.
• Accessor Generators - Reduces boilerplate by automatically generating getter and setter methods for instance variables.
• Exception Verification - Verifies that code blocks raise expected exceptions and validates error details.
• Splat Expansion - Flattens enumerable sources into collection literals using splat operators.
• Hardware Instruction Targeting - Targets specific hardware instructions or processor models for individual functions to achieve maximum performance gains.
• Test Configuration - Centralizes shared dependencies and utility methods to maintain consistency across the test suite.

Star history