GitHub All Languages Trending

The latest build: 2024-07-19Source of data: GitHubTrendingRSS

Brand new TTS solution

Fish Speech


Chinese README

This codebase and all models are released under CC-BY-NC-SA-4.0 License. Please refer to LICENSE for more details.


We do not hold any responsibility for any illegal usage of the codebase. Please refer to your local laws about DMCA and other related laws.

Online Demo

Fish Audio

Quick Start for Local Inference



V1.2 Demo Video:




The Abstraction and Reasoning Corpus

Abstraction and Reasoning Corpus for Artificial General Intelligence (ARC-AGI)

This repository contains the ARC-AGI task data, as well as a browser-based interface for humans to try their hand at solving the tasks manually.

"ARC can be seen as a general artificial intelligence benchmark, as a program synthesis benchmark, or as a psychometric intelligence test. It is targeted at both humans and artificially intelligent systems that aim at emulating a human-like form of general fluid intelligence."

A complete description of the dataset, its goals, and its underlying logic, can be found in: On the Measure of Intelligence.

As a reminder, a test-taker is said to solve a task when, upon seeing the task for the first time, they are able to produce the correct output grid for all test inputs in the task (this includes picking the dimensions of the output grid). For each test input, the test-taker is allowed 3 trials (this holds for all test-takers, either humans or AI).

Task file format

The data directory contains two subdirectories:

  • data/training: contains the task files for training (400 tasks). Use these to prototype your algorithm or to train your algorithm to acquire ARC-relevant cognitive priors.
  • data/evaluation: contains the task files for evaluation (400 tasks). Use these to evaluate your final algorithm. To ensure fair evaluation results, do not leak information from the evaluation set into your algorithm (e.g. by looking at the evaluation tasks yourself during development, or by repeatedly modifying an algorithm while using its evaluation score as feedback).

The tasks are stored in JSON format. Each task JSON file contains a dictionary with two fields:

  • "train": demonstration input/output pairs. It is a list of "pairs" (typically 3 pairs).
  • "test": test input/output pairs. It is a list of "pairs" (typically 1 pair).

A "pair" is a dictionary with two fields:

  • "input": the input "grid" for the pair.
  • "output": the output "grid" for the pair.

A "grid" is a rectangular matrix (list of lists) of integers between 0 and 9 (inclusive). The smallest possible grid size is 1x1 and the largest is 30x30.

When looking at a task, a test-taker has access to inputs & outputs of the demonstration pairs, plus the input(s) of the test pair(s). The goal is to construct the output grid(s) corresponding to the test input grid(s), using 3 trials for each test input. "Constructing the output grid" involves picking the height and width of the output grid, then filling each cell in the grid with a symbol (integer between 0 and 9, which are visualized as colors). Only exact solutions (all cells match the expected answer) can be said to be correct.

Usage of the testing interface

The testing interface is located at apps/testing_interface.html. Open it in a web browser (Chrome recommended). It will prompt you to select a task JSON file.

After loading a task, you will enter the test space, which looks like this:

test space

On the left, you will see the input/output pairs demonstrating the nature of the task. In the middle, you will see the current test input grid. On the right, you will see the controls you can use to construct the corresponding output grid.

You have access to the following tools:

Grid controls

  • Resize: input a grid size (e.g. "10x20" or "4x4") and click "Resize". This preserves existing grid content (in the top left corner).
  • Copy from input: copy the input grid to the output grid. This is useful for tasks where the output consists of some modification of the input.
  • Reset grid: fill the grid with 0s.

Symbol controls

  • Edit: select a color (symbol) from the color picking bar, then click on a cell to set its color.
  • Select: click and drag on either the output grid or the input grid to select cells.
    • After selecting cells on the output grid, you can select a color from the color picking to set the color of the selected cells. This is useful to draw solid rectangles or lines.
    • After selecting cells on either the input grid or the output grid, you can press C to copy their content. After copying, you can select a cell on the output grid and press "V" to paste the copied content. You should select the cell in the top left corner of the zone you want to paste into.
  • Floodfill: click on a cell from the output grid to color all connected cells to the selected color. "Connected cells" are contiguous cells with the same color.

Answer validation

When your output grid is ready, click the green "Submit!" button to check your answer. We do not enforce the 3-trials rule.

After you've obtained the correct answer for the current test input grid, you can switch to the next test input grid for the task using the "Next test input" button (if there is any available; most tasks only have one test input).

When you're done with a task, use the "load task" button to open a new task.

A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM.

A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM.

'Build' workflow StatusDiscord ServerTotal DownloadsCode QualityTranslationPlugins

Download the latest version of ImHex!Download the latest nightly pre-release version of ImHexUse the Web version of ImHex right in your browser!Read the documentation of ImHex!


If you like my work, please consider supporting me on GitHub Sponsors, Patreon or PayPal. Thanks a lot!

GitHub donate buttonPatreon donate buttonPayPal donate button


Hex editor, patterns and data informationBookmarks, disassembler and data processor

More Screenshots

Data Processor decrypting some data and displaying it as an imageSTL Parser written in the Pattern Language visualizing a 3D modelData Information view displaying various stats about the file


Featureful hex view
  • Byte patching
  • Patch management
  • Infinite Undo/Redo
  • "Copy bytes as..."
    • Bytes
    • Hex string
    • C, C++, C#, Rust, Python, Java & JavaScript array
    • ASCII-Art hex view
    • HTML self-contained div
  • Simple string and hex search
  • Goto from start, end and current cursor position
  • Colorful highlighting
    • Configurable foreground highlighting rules
    • Background highlighting using patterns, find results and bookmarks
  • Displaying data as a list of many different types
    • Hexadecimal integers (8, 16, 32, 64 bit)
    • Signed and unsigned decimal integers (8, 16, 32, 64 bit)
    • Floats (16, 32, 64 bit)
    • RGBA8 Colors
    • HexII
    • Binary
  • Decoding data as ASCII and custom encodings
    • Built-in support for UTF-8, UTF-16, ShiftJIS, most Windows encodings and many more
  • Paged data view
Custom C++-like pattern language for parsing highlighting a file's content
  • Automatic loading based on MIME types and magic values
  • Arrays, pointers, structs, unions, enums, bitfields, namespaces, little and big endian support, conditionals and much more!
  • Useful error messages, syntax highlighting and error marking
  • Support for visualizing many different types of data
    • Images
    • Audio
    • 3D Models
    • Coordinates
    • Time stamps
Theming support
  • Doesn't burn out your retinas when used in late-night sessions
    • Dark mode by default, but a light mode is available as well
  • Customizable colors and styles for all UI elements through shareable theme files
  • Support for custom fonts
Importing and Exporting data
  • Base64 files
  • IPS and IPS32 patches
  • Markdown reports
Data Inspector
  • Interpreting data as many different types with endianness, decimal, hexadecimal and octal support and bit inversion
    • Unsigned and signed integers (8, 16, 24, 32, 48, 64 bit)
    • Floats (16, 32, 64 bit)
    • Signed and Unsigned LEB128
    • ASCII, Wide and UTF-8 characters and strings
    • time32_t, time64_t, DOS date and time
    • GUIDs
    • RGBA8 and RGB65 Colors
  • Copying and modifying bytes through the inspector
  • Adding new data types through the pattern language
  • Support for hiding rows that aren't used
Node-based data pre-processor
  • Modify, decrypt and decode data before it's being displayed in the hex editor
  • Modify data without touching the underlying source
  • Support for adding custom nodes
Loading data from many different data sources
  • Local Files
    • Support for huge files with fast and efficient loading
  • Raw Disks
    • Loading data from raw disks and partitions
  • GDB Server
    • Access the RAM of a running process or embedded devices through GDB
  • Intel Hex and Motorola SREC data
  • Process Memory
    • Inspect the entire address space of a running process
Data searching
  • Support for searching the entire file or only a selection
  • String extraction
    • Option to specify minimum length and character set (lower case, upper case, digits, symbols)
    • Option to specify encoding (ASCII, UTF-8, UTF-16 big and little endian)
  • Sequence search
    • Search for a sequence of bytes or characters
    • Option to ignore character case
  • Regex search
    • Search for strings using regular expressions
  • Binary Pattern
    • Search for sequences of bytes with optional wildcards
  • Numeric Value search
    • Search for signed/unsigned integers and floats
    • Search for ranges of values
    • Option to specify size and endianness
    • Option to ignore unaligned values
Data hashing support
  • Many different algorithms available
    • CRC8, CRC16 and CRC32 with custom initial values and polynomials
      • Many default polynomials available
    • MD5
    • SHA-1, SHA-224, SHA-256, SHA-384, SHA-512
    • Adler32
    • AP
    • BKDR
    • Bernstein, Bernstein1
    • OneAtTime, Rotating, ShiftAndXor, SuperFast
    • Murmur2_32, MurmurHash3_x86_32, MurmurHash3_x86_128, MurmurHash3_x64_128
    • SipHash64, SipHash128
    • XXHash32, XXHash64
    • Tiger, Tiger2
    • Blake2B, Blake2S
  • Hashing of specific regions of the loaded data
  • Hashing of arbitrary strings
Diffing support
  • Compare data of different data sources
  • Difference highlighting
  • Table view of differences
Integrated disassembler
  • Support for all architectures supported by Capstone
    • ARM32 (ARM, Thumb, Cortex-M, AArch32)
    • ARM64
    • MIPS (MIPS32, MIPS64, MIPS32R6, Micro)
    • x86 (16-bit, 32-bit, 64-bit)
    • PowerPC (32-bit, 64-bit)
    • SPARC
    • IBM SystemZ
    • xCORE
    • M68K
    • TMS320C64X
    • M680X
    • Ethereum
    • RISC-V
    • WebAssembly
    • MOS65XX
    • Berkeley Packet Filter
  • Support for bookmarks with custom names and colors
  • Highlighting of bookmarked region in the hex editor
  • Jump to bookmarks
  • Open content of bookmark in a new tab
  • Add comments to bookmarks
Featureful data analyzer and visualizer
  • File magic-based file parser and MIME type database
  • Byte type distribution graph
  • Entropy graph
  • Highest and average entropy
  • Encrypted / Compressed file detection
  • Digram and Layered distribution graphs
YARA Rule support
  • Scan a file for vulnerabilities with official yara rules
  • Highlight matches in the hex editor
  • Jump to matches
  • Apply multiple rules at once
Helpful tools
  • Itanium, MSVC, Rust and D-Lang demangler based on LLVM
  • ASCII table
  • Regex replacer
  • Mathematical expression evaluator (Calculator)
  • Graphing calculator
  • Hexadecimal Color picker with support for many different formats
  • Base converter
  • Byte swapper
  • UNIX Permissions calculator
  • Wikipedia term definition finder
  • File utilities
    • File splitter
    • File combiner
    • File shredder
  • IEEE754 Float visualizer
  • Division by invariant multiplication calculator
  • TCP Client/Server
  • Euclidean algorithm calculator
Built-in Content updater
  • Download all files found in the database directly from within ImHex
    • Pattern files for decoding various file formats
    • Libraries for the pattern language
    • Magic files for file type detection
    • Custom data processor nodes
    • Custom encodings
    • Custom themes
    • Yara rules
Modern Interface
  • Support for multiple workspaces
  • Support for custom layouts
  • Detachable windows
Easy to get started
  • Support for many different languages
  • Simplified mode for beginners
  • Extensive documentation
  • Many example files available on the Database
  • Achievements guiding you through the features of ImHex
  • Interactive tutorials

Pattern Language

The Pattern Language is the completely custom programming language developed for ImHex. It allows you to define structures and data types in a C-like syntax and then use them to parse and highlight a file's content.


For format patterns, libraries, magic and constant files, check out the ImHex-Patterns repository.

Feel free to PR your own files there as well!


To use ImHex, the following minimal system requirements need to be met.

[!IMPORTANT] ImHex requires a GPU with OpenGL 3.0 support in general. There are releases available (with the -NoGPU suffix) that are software rendered and don't require a GPU, however these can be a lot slower than the GPU accelerated versions.

If possible at all, make ImHex use the dedicated GPU on your system instead of the integrated one. ImHex will usually run fine with integrated GPUs as well but certain Intel HD GPU drivers on Windows are known to cause graphical artifacts.

  • OS:
    • Windows: Windows 7 or higher (Windows 10/11 recommended)
    • macOS: macOS 12.1 (Monterey) or higher,
      • Lower versions are supported, but you'll need to compile ImHex yourself
    • Linux: "Modern" Linux. The following distributions have official releases available. Other distros are supported through the AppImage and Flatpak releases.
      • Ubuntu and Debian
      • Fedora
      • RHEL/AlmaLinux
      • Arch Linux
      • Basically any other distro will work as well when compiling ImHex from sources.
  • CPU: x86_64 (64 Bit)
  • GPU: OpenGL 3.0 or higher
    • Integrated Intel HD iGPUs are supported, however certain drivers are known to cause various graphical artifacts, especially on Windows. Use at your own risk.
    • In case you don't have a GPU available, there are software rendered releases available for Windows and macOS
  • RAM: 256MB, more may be required for more complicated analysis
  • Storage: 150MB


Information on how to install ImHex can be found in the Install guide


To compile ImHex on any platform, GCC (or Clang) is required with a version that supports C++23 or higher. On macOS, Clang is also required to compile some ObjC code. All releases are being built using latest available GCC.

[!NOTE] Many dependencies are bundled into the repository using submodules so make sure to clone it using the --recurse-submodules option. All dependencies that aren't bundled, can be installed using the dependency installer scripts found in the /dist folder.

For more information, check out the Compiling guide.


See Contributing

Plugin development

To develop plugins for ImHex, use the following template project to get started. You then have access to the entirety of libimhex as well as the ImHex API and the Content Registry to interact with ImHex or to add new content.



  • iTrooz for getting ImHex onto the Web as well as hundreds of contributions in every part of the project
  • jumanji144 for huge contributions to the Pattern Language and ImHex's infrastructure
  • Mary for her immense help porting ImHex to MacOS and help during development
  • Roblabla for adding MSI Installer support to ImHex
  • Mailaender for getting ImHex onto Flathub
  • Everybody else who has reported issues on Discord or GitHub that I had great conversations with :)


  • Thanks a lot to ocornut for their amazing Dear ImGui which is used for building the entire interface
    • Thanks to epezent for ImPlot used to plot data in various places
    • Thanks to Nelarius for ImNodes used as base for the data processor
    • Thanks to BalazsJako for ImGuiColorTextEdit used for the pattern language syntax highlighting
  • Thanks to nlohmann for their json library used for configuration files
  • Thanks to vitaut for their libfmt library which makes formatting and logging so much better
  • Thanks to btzy for nativefiledialog-extended and their great support, used for handling file dialogs on all platforms
  • Thanks to danyspin97 for xdgpp used to handle folder paths on Linux
  • Thanks to aquynh for capstone which is the base of the disassembly window
  • Thanks to rxi for microtar used for extracting downloaded store assets
  • Thanks to VirusTotal for Yara used by the Yara plugin
  • Thanks to Martinsos for edlib used for sequence searching in the diffing view
  • Thanks to ron4fun for HashLibPlus which implements every hashing algorithm under the sun
  • Thanks to mackron for miniaudio used to play audio files
  • Thanks to all other groups and organizations whose libraries are used in ImHex


The biggest part of ImHex is under the GPLv2-only license. Notable exceptions to this are the following parts which are under the LGPLv2.1 license:

  • /lib/libimhex: The library that allows Plugins to interact with ImHex.
  • /plugins/ui: The UI plugin library that contains some common UI elements that can be used by other plugins

The reason for this is to allow for proprietary plugins to be developed for ImHex.