Theos

Theos is a cross-platform mobile build system and development toolchain designed for creating system modifications and software for iOS and other mobile operating systems. It functions as a runtime hooking framework and a Cydia-style tweak development kit, providing the infrastructure necessary to intercept and modify application behavior at runtime.

The project is distinguished by its ability to translate high-level preprocessor syntax into low-level API calls, allowing for the replacement of function implementations without writing boilerplate code. It supports dynamic method swizzling, runtime class extensions, and binary lifecycle control, enabling custom logic to execute during the loading and unloading of binaries.

The toolchain covers a broad range of capabilities, including multi-architecture compilation for various processors and simulators, and the generation of multiple mobile package formats such as deb, ipa, pkg, and rpm. It manages the entire deployment pipeline through project scaffolding, dependency management, and the automation of installation scripts for local or remote device deployment.

Build orchestration is handled via a unified system that manages SDK integration, rootless environment path resolution, and the distribution of build tasks across multiple CPU cores.

Features

Mobile Build Toolchains - Provides a unified build toolchain to compile source code into signed, deployable binary packages for mobile platforms.
Tweak Development - Enables the creation of system extensions and plugins to customize the behavior of mobile operating systems.
Toolchains - Manages toolchains and SDKs to compile source code for multiple mobile operating systems and simulators.
Method Swizzling - Implements dynamic replacement of method implementations by swapping function pointers at runtime to modify system behavior.
Multi-Target Build Orchestrators - Manages complex project structures to compile a single source codebase into multiple binary targets for different architectures.
iOS Packaging Tools - Provides utilities for generating and signing iOS application packages for distribution.
Cross-Platform Build Systems - Automates the compilation and packaging of software for multiple target mobile operating systems and simulators.
Target-Specific Build Settings - Adapts the build process by importing system-specific frameworks and environment macros based on the target platform.
Build Target Definitions - Configures the target platform, compiler, SDK version, and deployment version for the build process.
Build Toolchain Abstractions - Provides an abstraction layer that maps generic build instructions to specific compiler flags for various mobile operating systems.
Source Compilation - Converts specialized mobile syntax into compatible object code based on provided file extensions.
Distribution Package Generators - Generates installation files using custom tools to ensure compatibility across platforms and compression formats.
Multi-Format Packaging Support - Supports the generation of multiple industry-standard packaging formats such as deb, ipa, pkg, and rpm.
Rootless iOS Installations - Adjusts install paths and library load paths to ensure compatibility with rootless iOS environments.
iOS Development - Provides a complete environment for developing applications specifically for the iOS and Apple platform ecosystem.
Mobile Application Packaging - Bundles compiled code into multiple mobile formats including .deb, .ipa, .pkg, and .rpm.
Native Runtime Hooking - Implements mechanisms for intercepting internal application events by attaching listeners to the native mobile runtime.
Rootless Path Resolution - Converts file paths from rootful to rootless using compile-time macros based on the active platform.
Runtime Hooking Frameworks - Provides a framework for intercepting and replacing function calls within a running process to modify behavior.
Cross-Platform Compilers - Compiles and packages code for multiple mobile operating systems from a single development environment.
Source Code Compilers - Builds project source files into binaries with options to clean previous builds or increase debug verbosity.
Original Call Triggers - The Logos tool allows triggering the original version of a hooked function from within a custom implementation to maintain base functionality.
Runtime Method Hooking - Translates high-level syntax into low-level API calls to replace function implementations at runtime.
Method Hooking - Intercepts and redirects function calls at runtime by injecting code into memory via automated generators.
Preprocessor Hook Generation - Translates high-level preprocessor syntax into low-level API calls to intercept functions and methods without boilerplate code.
Automated Installation Scripts - Executes custom scripts during installation and removal to handle complex setup or cleanup tasks.
Build Optimization - Reduces the final package size by removing debug symbols and applying optimization levels during the build process.
Compiler Flag Customization - Sets compiler and linker flags for projects, individual files, or specific target architectures.
iOS Simulator Builds - Configures build targets for simulators by managing architecture selection and disabling runtime links.
Swift Cross-Platform Compilers - Compiles Swift source code into native binaries and integrates them with other languages across multiple operating systems.
Toolchain Managers - Toggles module support for third-party toolchains to resolve build errors on the host machine.
Build Task Parallelism - Distributes build tasks across available CPU cores to reduce the total time required to compile large projects.
User Configuration Separation - Loads environment-specific variables from a global config file to prevent local paths from being committed.
Installation Lifecycle Scripts - Executes specific commands during the installation or removal of a package on the target platform.
Project Generation Hooks - Runs custom scripts during project creation to modify templates based on the current environment.
Package Hierarchy Staging - Constructs the file system layout and places build artifacts into a directory for final packaging.
Host-to-Device Package Installations - Deploys built packages to local or remote target environments and manages the removal of existing installations.
Project Bootstrapping Templates - Generates new project instances using predefined blueprints for various app types and libraries.
Build Environment Configurations - Supports defining build environment variables in a global configuration file to ensure project portability.
Project Scaffolding - Generates initial project structures and files using predefined templates to accelerate development.
Project Templates - Packages project structures into archive files and manages reusable blueprints via scripts.
SDK Integrations - Integrates external development kits and toolchains to maintain compatibility with specific operating system versions.
Remote Software Deployers - Transfers and installs built packages to remote target devices using network credentials.
Initialization Hooks - Groups and controls the activation of related hooks and their target classes during application startup.
Build Lifecycle Hooks - Executes custom tasks at specific stages of the build process such as before cleaning or during packaging.
Arm64e Architecture Support - Produces binaries compatible with arm64e processors to enable code injection into platform binaries.
Deployment Packaging - Bundles compiled binaries and assets into a distributable package with options to strip symbols.
Debian Package Builds - Creates .deb files from a project directory without requiring external toolsets.
Staging-Area Packaging - Constructs a temporary file system hierarchy of build artifacts before compressing them into platform-specific installation packages.
Package Metadata - Defines package identifiers, versioning, and architectural targets using control files.
Binary Execution Lifecycle Hooks - Executes custom logic automatically when a binary loads into memory or before it unloads from the system.
Injection Filter Lists - Specifies target bundles or executables via a filter list to ensure code only loads into intended processes.
Rootless Path Resolutions - Converts file paths between rootful and rootless environments at compile time using platform-specific macros.
Runtime Class Modifications - Allows adding new methods or properties to existing classes while the application is running.
Language Interoperability - Exposes classes and headers between different programming languages using bridging headers and generated modules.
System Modification Runtimes - Allows developing system modifications using the Swift language by leveraging a dedicated runtime.
Environment Variable Sets - Toggles groups of master variables to quickly switch between different build profiles like debug or release.
Library Dependency Managers - Provides configuration for project dependencies and linker search paths for external libraries.
Runtime Argument Inspection - Dumps method arguments and typed values to the system log to facilitate debugging of hooked functions.
Boilerplate Reduction - Uses a preprocessor to remove boilerplate code required for redirecting methods and functions.
iOS Jailbreaking - Cross-platform suite for building and deploying iOS software.

Nuitka/Nuitka

14,938View on GitHub

Nuitka is a compilation framework that translates Python source code into C, enabling the creation of standalone machine code binaries. By converting interpreted scripts into compiled executables, it removes the requirement for a language interpreter on the target machine and provides a mechanism for distributing Python applications as self-contained packages. The project distinguishes itself through advanced optimization techniques, including link-time code generation and profile-guided binary optimization, which improve execution speed by bypassing standard interpreted overhead. It manages

premake/premake-core

3,566View on GitHub

Premake is a build system generator and cross-platform build configuration tool. It functions as a scripting engine that transforms scripted workspace definitions into native project files for multiple build toolsets and compilers. Additionally, it can generate JSON-formatted compilation databases for use with language servers and static analysis tools. The project distinguishes itself through a programmable runtime that allows for internal function hooking and the interception of build logic. This extensibility enables users to create custom toolset generators, implement modular extensions f

Aefyr/SAI

3,430View on GitHub

SAI is a binary package bundler and application manager designed for Android and iOS. It functions as an installer and export tool that packages application source files and metadata into a proprietary format for portable distribution and backup. The project features a rootless application deployment pipeline, allowing the installation of third-party packages on mobile devices without requiring system-level root access. It includes a split archive reconstructor to reassemble fragmented application files into complete installation directories during deployment. The tool covers Android split A

swiftlang/swift-package-manager

10,172View on GitHub

Swift Package Manager is a build tool, dependency manager, and registry client for the Swift language. It transforms source files and external dependencies into executable binaries or libraries and manages the resolution, download, and integration of external code libraries. The project provides a client for publishing and versioning signed code packages via a remote registry, ensuring identity verification through digital signing. It also includes a source code formatter to standardize code style and indentation. The system covers a broad range of capabilities including modular code distrib

theostheos

Features