premake/premake-core

Features

• Build Configuration Languages - Uses a domain-specific scripting language to define workspaces, compiler flags, and linker settings instead of manual IDE configuration.
• Build System Abstractions - Functions as a meta-build system that generates native project files for multiple different build systems and platforms.
• IDE Project Generators - Transforms scripted project definitions into native project files for a wide variety of IDEs and compilers.
• Project File Generators - Implements a script-based system that generates project files for various IDEs and build toolsets.
• Automation Scripting Engines - Provides a programmable runtime for executing scripts that automate the creation of project hierarchies and build settings.
• Cross-Platform Build Systems - Automates the configuration of software to be compiled across different operating systems and hardware architectures.
• Compiler Flag Customization - Provides interfaces for setting compiler flags and target architectures on a per-project or per-file basis.
• Compilation Setting Configuration - Offers a unified scripting interface to specify compiler options and platform flags to control code processing.
• Cross-Platform Build Systems - Manages hardware and operating system variations by defining platform-specific build axes and toolset requirements.
• Build Target Definitions - Allows users to define build target artifacts, including source files, languages, and output types for binaries.
• Cross-Platform Path Manipulation - Resolves absolute paths and normalizes path separators to ensure consistency across different operating systems.
• Custom Toolset Generators - A functionality that transforms scripted definitions into compatible files for various build toolsets and editors.
• Build Property Propagation - Tracks how include directories and library requirements flow from a defining project to its recursive consumers.
• Programmable Build Logic - Provides a programmable runtime to execute complex build logic and file management during project configuration.
• Source File Management - Implements a system for specifying the code and resource files to be included in a build using paths or recursive wildcards.
• Workspace Configurations - Offers a scripting interface to define workspaces and project configurations for software build processes.
• Workspace Container Management - Implements top-level workspace containers that manage shared configurations and global settings inherited by projects.
• Project Hierarchies - Uses a scripted inheritance model to organize source files and settings into nested workspaces and projects.
• Function Hooking - Implements a programmable runtime that allows hooking into internal functions to alter execution flow and add new actions.
• Domain Specific Languages - Uses a custom scripting language to describe project hierarchies and build settings instead of static configuration files.
• Embedded Scripting Extensions - Uses an embedded scripting language to define project structures and automate the build configuration process.
• Global and Project Scopes - Organizes build settings into global and project scopes to share common values across multiple targets.
• Conditional Build Configuration - Supports targeting project settings to specific build configurations or platforms using matching patterns.
• Hierarchical Configuration Systems - Implements a workspace and project nesting structure to inherit and override build settings across multiple targets.
• Library Dependency Managers - Defines include directories and library search paths to ensure external dependencies are correctly located during linking.
• Language and Framework Support Modules - Allows extending the build system with modular support for new languages and frameworks through add-on modules.
• Build Configuration Mappings - A system for translating global workspace configurations to project-specific values and restricting profile application.
• Custom Build Hooks - Allows the addition of shell commands or executable calls to handle non-standard compilation steps.
• Custom Build Rules - Provides a system for specifying custom build actions and dependencies to control compilation and linking.
• Scripted Logic Overrides - Provides a scripting environment to overwrite internal functions and call arrays to modify project processing.
• Build Output Directories - Provides functionality to define and manage the directories where generated workspace and project files are stored.
• Reusable Compilation Property Sets - Implements named sets of build properties to share consistent compiler and linker settings across targets.
• Command Flag Configurations - Provides a system for defining user-configurable flags and enumerated lists that trigger specific configuration logic.
• Command Line Extensions - Allows the definition of named custom commands that execute specific internal functions when triggered via CLI.
• Compilation Database Generators - Produces JSON-formatted compilation databases to provide language servers and static analysis tools with project structure information.
• Library Search Paths - Allows developers to define the directories where the build system searches for library files during the linking phase.
• Reusable Build Instructions - Provides a system for creating reusable sets of build instructions that apply across multiple projects or targets.
• Platform Axes - Establishes configuration axes to handle variations in target hardware or operating systems.
• Cross-Platform Scripting Runtimes - Enables scripting of portable command-line actions for installation and cleanup tasks across different operating systems.
• Reusable Build Parameters - A system for defining reusable sets of build and link parameters in functions to ensure consistency across projects.
• Task Automation Scripts - Provides a runtime for executing portable automation scripts to handle maintenance tasks like source checkouts and packaging.
• Third-Party Toolset Integrations - Allows integrating third-party scripts to extend the build system with support for new toolsets and languages.
• Build Automation - Provides a system for configuring pre-build and post-build commands and custom build rules to automate the build process.
• Per-File Build Settings - Allows assigning specific build settings and configurations to individual files instead of applying them globally.
• Project Metadata Specifications - Provides a system for specifying project names and target directories to organize generated build files.
• Static Linking Configurations - Provides capabilities for specifying the libraries, frameworks, and search directories required for linking the final binary.
• Build System Extensibility - Enables the addition of custom build logic and new output formats through modular extensions and action handlers.
• Platform Support - Enables the definition of new target platforms within scripts to tailor output for specific hardware.
• Build-Time Optimization Configuration - Provides capabilities for setting up precompiled headers and toggling optimization levels for size or speed.
• External Library Linking - Provides a mechanism to specify external libraries and synthesize platform-specific linking prefixes and extensions.
• Preprocessor and Include Configurations - Provides a capability for setting preprocessor symbols and include directories to control the compilation process.
• Compilation Dialect Configuration - Provides a scripting interface for setting language dialects, optimization levels, and preprocessor defines.
• Dynamic Function Interception - Provides a mechanism to intercept internal functions and modify the project generation sequence at runtime.
• Modular Extension Systems - Enables the addition of support for new compilers or IDEs via custom action handlers and markup emitters.
• Dependency Requirement Propagation - Provides logic to propagate build properties and include requirements from a project to its recursive consumers.
• Build Systems - Generates build scripts for various IDEs and toolsets.

Star history