red/red
Red
Red is a programming language with a native compiler that translates high-level source code into standalone executables for Windows, macOS, and Linux without external runtime dependencies. It combines a cross-platform GUI development framework that renders native operating system widgets from a single codebase with a reactive data binding system that automatically synchronizes UI state with data sources. The language also includes an embedded DSL and parsing engine based on PEG grammar rules for defining and processing domain-specific languages within the language itself.
The project distinguishes itself through its ability to serve as both a low-level system programming language with inline assembly, raw memory manipulation, and hardware access, and as a high-level scripting environment with a precise stack-scanning garbage collector. It supports native-code compilation through a C-like intermediate language, compile-time preprocessing with macros, and a dialect-based embedded DSL system. The language provides a foreign function interface for calling external C libraries, an HTTP client for network communication, and a bridge to the Java Virtual Machine for interoperability with Java classes and objects.
The language includes a comprehensive build toolchain with support for cross-compilation to multiple platforms including Android and WebAssembly, a REPL for interactive code execution, and both development and release compilation modes. It offers actor-based concurrency with message passing, parallel collection processing, and cross-platform threading. The GUI system supports declarative layouts, vector graphics, image processing, input handling including touch gestures and drag-and-drop, and text-based user interfaces rendered in the terminal using ANSI escape codes.
The project provides a PEG-based parse dialect engine for structured data validation and extraction, a pluggable codec serialization framework supporting formats like JSON and CSV, and tools for debugging and profiling both interpreted and compiled code. It can be installed via package managers such as Chocolatey on Windows.
Features
- Standalone Executable Compilers - Compiles high-level source code into self-contained native binaries under 1 MB with no runtime requirements.
- Native Executable Compilers - Compiles source code directly to standalone executables that require no external runtime or shared libraries.
- Parsing and Grammars - Parses strings and blocks against declarative grammar rules using a built-in PEG engine.
- PEG-Based Parse Dialects - Provides a built-in PEG-based parse dialect for matching and extracting structured data from text.
- Standalone Binary Compilation - Compiles source code into a self-contained binary with no external dependencies for distribution.
- Block-Structure DSLs - Uses the Parse dialect to create embedded DSLs that operate on block values for code generation.
- Reactive GUI Components - Connects widget properties to data sources so UI elements update automatically when values change.
- Native GUI Builders - Enables building native GUI applications with no external dependencies using built-in dialects.
- Low-Level Systems Programming - Offers a low-level DSL for system programming alongside high-level scripting features.
- Cross Compilation Toolchains - Compiles and cross-compiles programs to multiple targets including Android and WebAssembly from a single environment.
- C-Like Intermediate Languages - Translates high-level Red code into a C-like intermediate representation before generating native machine code.
- Dependency-Free Runtimes - Produces standalone binaries under 1 MB that run without any runtime or libraries.
- Cross-Platform GUI Frameworks - Builds native graphical user interfaces from a single codebase using declarative layout dialects and reactive data binding.
- Data-to-UI Bindings - Links face objects to data sources so changes propagate automatically between model and display.
- Declarative UI Dialects - Ships a declarative UI dialect that compiles to a face tree for describing layouts and behaviors.
- GUI Widget Toolkits - Provides a cross-platform GUI framework that renders native OS widgets from a single codebase.
- Cross-Platform Native GUI Builders - Builds native GUI applications for Windows, macOS, and Linux from a single codebase.
- Cross-Platform Native Renderers - Builds graphical applications with native OS widgets that run on Windows, macOS, and Linux from a single codebase.
- Native Widget Mapping - Maps declarative GUI layouts to native OS widgets across Windows, macOS, and Linux.
- Reactive Data Binding - Automatically synchronizes user interface state with data sources so changes propagate bidirectionally.
- Capture Groups from Parse Rules - Captures matched substrings during grammar-based parsing for further processing.
- Pattern-Based Validators - Validates strings against complex patterns like IP addresses and email addresses using composable rules.
- Macro-Based Code Transformations - Ships a compile-time macro system for rewriting and generating code to reduce boilerplate.
- Debug Symbol Compilations - Compiles Red source files with debug symbols for source-level debugging on supported targets.
- Language REPL Consoles - Interactively executes Red code in a command-line or graphical read-eval-print loop.
- Language REPL Consoles - Executes Red code line by line in a REPL console for rapid prototyping and testing.
- Preprocessing Interpreters - Provides a built-in interpreter that applies preprocessing and macro expansion before execution.
- Declarative Drawing Dialects - Renders vector graphics and shapes using a dedicated declarative drawing dialect within the GUI system.
- Stack-Scanning Garbage Collectors - Traces live references by scanning the call stack precisely for safe memory management.
- Cross-Platform Compilers - Generates executables targeting different operating systems or architectures from the development machine.
- External Library Integrations - Imports and calls functions from shared libraries using the #import directive.
- Shared Library Compilers - Compiles Red source files into dynamically linked libraries usable by other programs.
- Runtime Exception Handling - Throws and catches exception values to manage error conditions during program execution.
- Actor-Based Concurrency - Supports concurrent execution through message-passing actors, parallel collection processing, and cross-platform threading.
- Reactive Field Bindings - Links object fields to data sources so changes propagate automatically between model and display.
- Typed Variable Declarations - Declares variables with explicit types such as integer, byte, float, and pointer before use.
- Memory Pointers - Reads and writes memory through typed pointers with support for pointer arithmetic and type casting.
- Compilers and Interpreters - Red programming language implementation.
- Desktop Application Frameworks - Provides a graphic system and visual interface dialect for Red.
