amber-lang/amber

Features

• Source-to-Shell Translation - Translates high-level source code into executable Bash, Zsh, and Ksh scripts for automation.
• Shell Script Transpilers - Translates high-level source code into executable Bash, Zsh, and Ksh scripts for cross-shell compatibility.
• Shell Command Execution - Provides an operator for running system commands with integrated failure halting.
• Standalone Scripts - Generates self-contained executable scripts that function independently without requiring a compiler at runtime.
• Source Code Module Imports - Manages code reuse through a module-based system for importing and exporting functions and variables across files.
• Basic Data Type Definitions - Includes a type system for managing primitive data types such as text, integers, floats, and booleans.
• External Module Imports - Implements mechanisms for loading functions and variables from external files to reuse logic across the project.
• Static Type Validation - Identifies bugs and type mismatches during the build process before the generated shell script is executed.
• Executable Entry Points - Provides a dedicated code block for handling arguments and exit codes during direct execution of scripts.
• Shell Compatibility Layers - Generates scripts compatible with Bash, Zsh, and Ksh using portable shebangs.
• Shell Script Compilers - Transforms high-level source code into executable Bash, Ksh, and Zsh scripts.
• Type Validation - Provides a system to validate that passed values match supported data types at runtime.
• Tree-Shaken Imports - Includes specific functions from a module while automatically omitting unused code during the compilation process.
• Compile-Time Type Validation - Features a type system that identifies bugs and type mismatches during the compilation process.
• Out-of-Bounds Protection - Deno Shell support for storing, retrieving, and slicing values with out-of-bounds protection.
• Compiler Configurations - Provides settings to adjust compiler behavior, including function-level restrictions and warnings regarding global state.
• Dependency Verification - Verifies the presence of required external commands in compiled scripts to prevent runtime failures.
• Documentation Generators - Extracts triple-slash comments from source code to automatically generate Markdown documentation.
• Child Exit Status Retrievals - Provides a utility to retrieve the exit status of the most recently executed failing function.
• Execution Modifiers - Ships with modifiers to suppress command output or bypass failure checks during function calls.
• Compile-and-Run Workflows - Allows source code to be compiled to a shell script and executed in one integrated step.
• Shell Script Wrappers - Injects custom header and footer files into the compiled shell script output using templates.
• Dead Code Analysis - Analyzes control flow to identify unreferenced declarations and variables that should be constants.
• Command Failure Enforcements - Enforces strict error handling by preventing compilation if potential command failures are not handled.
• Script Footer Templates - Injects custom header and footer files into compiled output using environment variables and template tags.
• Symbol Visibility Controls - Provides visibility keywords to control which functions and variables are exposed to importers in other files.
• Variable Exports - Enables exposing specific variables to other files to facilitate shared state access.
• Symbol Re-exports - Allows importing symbols from one module and making them available for export through a single entry point.
• Object and Array Destructuring - Implements the capability to unpack array elements into separate individual variables.
• Failable Functions - Supports marking functions as failable to trigger specific shell exit codes upon failure.
• Text Interpolations - Supports embedding variables and data types directly into text literals.
• Type Casting - Supports explicit conversion of values between different data types for compatibility.
• Union Types - Allows function parameters to accept one of several distinct member types via union types.
• Arithmetic Operations - Supports basic mathematical calculations including sums, differences, products, and remainders.
• Job Lifecycle Management - Provides capabilities for tracking process IDs and managing the lifecycle of background jobs.
• Dynamic Arrays - Provides resizable array implementations that manage element storage dynamically.
• Error Propagation Systems - Implements mechanisms for passing command failures back to the calling context for robust error handling.
• Reference Argument Passing - Supports passing variables by reference, allowing functions to modify original values instead of copies.
• Public Visibility Declarations - Supports declaring variables as public to expose them across multiple files.
• Variable Usage Analysis - Performs static analysis of control flow to identify unused declarations and constants.
• Automated Test Execution - Provides a recursive execution engine for test blocks to verify behavior under different conditions.
• Built-in Testing Frameworks - Ships an integrated testing environment as part of the language core to validate logic via test blocks and assertions.
• Integrated Logic Testing - Ships a built-in runner for validating the integrated logic of different system components.
• Value Equality Assertions - Provides utilities to check boolean conditions or value equalities and trigger error codes.
• Built-in Unit Tests - Includes a built-in runner for writing and validating individual code functionality via test blocks.
• Shell Script Validators - Includes a linting tool that reports validation issues for the compiled shell scripts.
• Tree-Shaking Optimizers - Optimizes output size by omitting unused library functions from the final generated shell script.

Star history