jart/blink
Blink
Blink is a JIT-based instruction emulator and x86-64 Linux emulator designed to run Linux binaries and ELF files across different host operating systems and architectures. It functions as a binary execution sandbox and system call simulator, providing a controlled environment for running programs.
The project distinguishes itself with a terminal user interface for monitoring execution, managing breakpoints, and visualizing JIT compilation paths. It supports self-modifying code through a cache-invalidating memory model and provides execution environment isolation using restricted directory overlays and mock filesystem interfaces.
The emulator covers a wide range of binary formats, including static and dynamic ELF files, raw flat binaries, and real mode programs for legacy software. Its analysis capabilities include system call tracing, symbolic breakpoints, and watchpoint debugging to inspect the state of the virtual machine.
TUI application hosting is supported through an ANSI-compatible pseudoteletypewriter interface.
Features
- Linux Environment Emulation - Simulates an x86-64 Linux environment to run Linux binaries across different host operating systems and architectures.
- Just-In-Time Compilation - Implements a JIT-based instruction emulator that translates guest instructions into native host machine code for performance.
- Isolated Execution Environments - Isolates binaries using restricted directory overlays and chroot environments to prevent interference with the host system.
- Code Execution Sandboxes - Isolates binaries within restricted directory overlays and virtual filesystems to prevent host interference.
- Instruction-Level Emulators - Uses just-in-time compilation to translate guest x86-64 instructions into native host machine code.
- Binary Loaders - Parses and loads static and dynamic ELF binaries into guest memory to initiate execution.
- Multi-Format Binary Loaders - Supports the execution of various binary formats including static and dynamic ELF files, PE, and raw flat binaries.
- Virtual Filesystem Mappings - Simulates a virtual root filesystem by mapping physical host directories to the guest environment.
- Binary Execution Sandboxes - Provides a restricted environment that isolates binaries using directory overlays and mock filesystem interfaces.
- System Call Tracing - Intercepts and records guest kernel system calls, including arguments and return values, for behavioral analysis.
- Instruction Cache Invalidations - Provides a memory model that purges translated code blocks from the JIT cache when executable memory is modified.
- Dynamic Behavioral Analysis - Traces system calls and logs execution flow to analyze how programs interact with the operating system.
- Symbolic Breakpoints - Allows pausing guest execution at specific memory addresses or symbolic names for state inspection.
- Low-Level Debuggers - Enables inspection of virtual machine state via breakpoints and JIT visualization to troubleshoot machine code.
- PTY Interfaces - Implements an ANSI-compatible pseudoteletypewriter interface to support guest TUI applications.
- Real-Mode Execution - Supports real-mode execution to boot legacy i8086 programs and simulated BIOS environments.
- Instruction-Level Debugging - Provides breakpoint and watchpoint debugging to inspect the virtual machine's state during execution.
- JIT Disassembly Analyzers - Visualizes the formation of compiled paths within an assembly view using a terminal user interface.
- Emulator Management Interfaces - Provides a terminal user interface for monitoring execution, managing breakpoints, and visualizing JIT paths.
- Terminal Emulators - Renders guest terminal applications through an xterm-compatible ANSI pseudoteletypewriter interface.
- Development Tools - Debug x86-64 or i8086 programs across platforms.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
