HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
google
highway
C++2020–2026
google / highway

highway

Performance-portable, length-agnostic SIMD with runtime dispatch

37Distinct people
107Mentions
1Explicit recommenders
6KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Performance-portable, length-agnostic SIMD with runtime dispatch

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

> but that algorithm requires costly preprocessing of the set to be matched. For string functions, input strings are usually very short > the advantage of longer vectors…

janwas used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 3:38:16 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year107 dated mentions

Observed mentions: 2020-08-04 18:38:08 UTC to 2026-09-25 20:11:25 UTC.

01020302020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 9 mentions; 1 submissions, 8 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 24 mentions; 1 submissions, 23 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 30 mentions; 1 submissions, 29 comments20232024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 18 mentions; 2 submissions, 16 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 13 mentions; 0 submissions, 13 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 12 mentions; 2 submissions, 10 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC101
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC918
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC24123
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC30129
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC18216
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC13013
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC12210

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
Efficient and performance-portable vector software Highway is a C++ library that provides portable SIMD/vector intrinsics. Documentation Previously licensed under Apache 2, now dual-licensed as Apache 2 / BSD-3. Why We are passionate about high-performance software. We see major untapped potential in CPUs (servers, mobile, desktops). Highway is for engineers who want to reliably and economically push the boundaries of what is possible in software. How CPUs provide SIMD/vector instructions that apply the same operation to multiple data items. This can reduce energy usage e.g. fivefold because fewer instructions are executed. We also often see 5-10x speedups. Highway makes SIMD/vector programming practical and workable according to these guiding principles: Does what you expect: Highway is a C++ library with carefully-chosen functions that map well to CPU instructions without extensive compiler transformations. The resulting code is more predictable and robust to code changes/compiler updates than autovectorization. Works on widely-used platforms: Highway supports seven architectures; the same application code can target various instruction sets, including those with 'scalable' vectors (size unknown at compile time). Highway only requires C++17 (language features, not necessarily the library) and supports four families of compilers. If you want to use Highway on other platforms, please raise an issue. Flexible to deploy: Applications using Highway can run on heterogeneous clouds or client devices, choosing the best available instruction set at runtime. Alternatively, developers may choose to target a single instruction set without any runtime overhead. In both cases, the application code is the same except for swapping HWY_STATIC_DISPATCH with HWY_DYNAMIC_DISPATCH plus one line of code. See also @kfjahnke's introduction to dispatching. Suitable for a variety of domains: Highway provides an extensive set of operations, used for image processing (floating-point), compression, video analysis, linear algebra, cryptography, sorting and random generation. We recognise that new use-cases may require additional ops and are happy to add them where it makes sense (e.g. no performance cliffs on some architectures). If you would like to discuss, please file an issue. Rewards data-parallel design: Highway provides tools such as Gather, MaskedLoad, and FixedTag to enable speedups for legacy data structures. However, the biggest gains are unlocked by designing algorithms and data structures for scalable vectors. Helpful techniques include batching, structure-of-array layouts, and aligned/padded allocations. We recommend these resources for getting started: SIMD programming with Highway talk SIMD for C++ Developers Algorithms for Modern Hardware Optimizing software in C++ Improving performance with SIMD intrinsics in three use cases Examples Online demos using Compiler Explorer: multiple targets with dynamic dispatch (more complicated, but flexible and uses best available SIMD) single target using -m flags (simpler, but requires/only uses the instruction set enabled by compiler flags) We have prepared several tutorial-like examples in hwy/examples; see the README.md there for more information. Basics: sum_array_advanced.cc: 4x unrolling and remainder handling. dot_product_unroll.cc: similar to sum_array_advanced, plus reduction. matrix_transpose_scatter_gather: shows/compares Scatter and Gather. Infrastructure: benchmark.cc: dot product with remainder-free loops and benchmarking. profiler_example: shows how to use the our built-in profiler for measuring the time cost of annotated zones. skeleton*: a complete example of a module with runtime dispatch. Challenges: masks_and_logic.cc: visualizes masks/comparisons with ASCII art. ctf_aes.cc: capture the flag, brute-force AES password guessing. We observe that Highway is referenced in the following open source projects, found via sourcegraph.com. Most are GitHub repositories. If you would like to add your project or link to it directly, feel free to raise an issue or contact us via the below email. Audio: Zimtohrli perceptual metric Browsers: Chromium (+Vivaldi), Firefox (+floorp / foxhound / librewolf / Waterfox) Computational biology: RNA analysis, long-sequence preprocessing Computer graphics: ghostty-org/ghostty, Sparse voxel renderer, tgfx 2D Graphics library Cryptography: google/distributed_point_functions, google/shell-encryption Data structures: bkille/BitLib Image codecs: eustas/2im, Grok JPEG 2000, JPEG XL, JPEGenc, Jpegli, libaom, OpenHTJ2K Image processing: awxkee/aire, cloudinary/ssimulacra2, libvips, m-ab-s/media-autobuild_suite, Image viewers: AlienCowEatCake/ImageViewer, diffractor/diffractor, Lux panorama/image viewer, mirillis/jpegxl-wic Information retrieval: iresearch database index, michaeljclark/zvec, nebula interactive analytics / OLAP, ScaNN Scalable Nearest Neighbors, Machine learning: array2d/deepx, gemma.cpp, Tensorflow, Numpy, zpye/SimpleInfer Programming languages: AOT-compiled python, oven-sh/bun, V8/V8, yinqiwen/rapidudf Robotics: MIT Model-Based Design and Verification Vector search: 1yefuwang1/vectorlite, vespa-engine/vespa Other Evaluation of C++ SIMD Libraries: "Highway excelled with a strong performance across multiple SIMD extensions [..]. Thus, Highway may currently be the most suitable SIMD library for many software projects." zimt: C++11 template library to process n-dimensional arrays with multi-threaded SIMD code vectorized Quicksort (paper) Highway can also be installed via a package manager or from a repository: Click to expand BSD repositories DragonFlyBSD FreeBSD GhostBSD MidnightBSD Click to expand cross platform package repositories conan-io conda-forge EasyBuild Homebrew microsoft/vcpkg spack xmake-io/xmake-repo Click to expand linux package repositories Obtained from repology Click to expand Windows package repositories fd00/yacp MSYS2 Click to expand other operating
Read the full README on GitHub

What Hacker News says

30 sources
"Introduction to Datalog" re: Linked Data https://news.ycombinator.com/context?id=34808887 pyDatalog/examples/SQLAlchemy.py: https://github.com/baojie/pydatalog/blob/master/pyDatalog/ex... GH topics > datalog: https://github.com/topics/datalog datalog?l=rust: https://github.com/topics/datalog?l=rust ... Cozo, Crepe Crepe: https://github.com/ekzhang/crepe : > Crepe is a library that allows you to write declarative logic programs in Rust, with a Datalog-like syntax. It provides a procedural macro that generates efficient, safe code and interoperates seamlessly with Rust programs. Looks like there's not yet a Python grammar for the treeedb tree-sitter: https://github.com/langston-barrett/treeedb : > Generate Soufflé Datalog types, relations, and facts that represent ASTs from a variety of programming languages. Looks like roxi supports n3,
Read the rest
which adds `=>` "implies" to the Turtle lightweight RDF representation: https://github.com/pbonte/roxi FWIW rdflib/owl-rl: https://owl-rl.readthedocs.io/en/latest/owlrl.html : > simple forward chaining rules are used to extend (recursively) the incoming graph with all triples that the rule sets permit (ie, the “deductive closure” of the graph is computed). ForwardChainingStore and BackwardChainingStore implementations w/ rdflib in Python: https://github.com/RDFLib/FuXi/issues/15 Fast CUDA hashmaps Gdlog is built on CuCollections. GPU HashMap libs to benchmark: Warpcore, CuCollections, https://github.com/NVIDIA/cuCollections https://github.com/NVIDIA/cccl https://github.com/sleeepyjack/warpcore /? Rocm HashMap DeMoriarty/DOKsparse: https://github.com/DeMoriarty/DOKSparse /? SIMD hashmap Google's SwissTable: https://github.com/topics/swisstable rust-lang/hashbrown: https://github.com/rust-lang/hashbrown CuPy has array but not yet hashmaps, or (GPU) SIMD FWICS? NumPy does SIMD: https://numpy.org/doc/stable/reference/simd/ google/highway: https://github.com/google/highway xtensor-stack/xsimd: https://github.com/xtensor-stack/xsimd GH topics > HashMap: https://github.com/topics/hashmap
In GDlog: A GPU-accelerated deductive engine
Interesting, thanks for sharing :) At the time we open-sourced Highway, the standardization process had already started and there were some discussions. I'm curious why stdlib is the only path you see to default? Compare the activity level of https://github.com/VcDevel/std-simd vs https://github.com/google/highway. As to open-source usage, after years of std::experimental, I see <200 search hits [1], vs >400 for Highway [2], even after excluding several library users. But that aside, I'm not convinced standardization is the best path for a SIMD library. We and external users extend Highway on a weekly basis as new use cases arise. What if we deferred those changes to 3-monthly meetings, or had to wait for one meeting per WD, CD, (FCD), DIS, (FDIS) stage before it's standardized? Standardization seems more useful for rarely-changing things
Read the rest
In SIMD Everywhere Optimization from ARM Neon to RISC-V Vector Extensions
I'm curious what is the new momentum? It's difficult to understand the value proposition of std::experimental::simd. Standardization has taken many years, lost the "load/store" function naming which just about everyone everywhere(?) is using, and only resulted in ~30 ops [1] that are also mostly achievable with compiler builtins or perhaps even autovectorization. Four years ago, we stepped in with Highway to fill the gap; it now has about 250 ops [2] and an active community. I have not wanted to step on any toes, but wonder whether the ship has by now sailed on this? [1]: https://en.cppreference.com/w/cpp/header/experimental/simd [2]: https://github.com/google/highway/blob/master/g3doc/quick_re...
In SIMD Everywhere Optimization from ARM Neon to RISC-V Vector Extensions
Ah thank you for clarifying so you would have to create an abstraction layer on top of the current simd implementation like for example simd_vector(type, size). That abstraction would have to dynamically detect the hardware and dispatch it to the hardware like the project you shared (https://github.com/google/highway). So technically it sounds feasible but all of the languages like Zig, C++ and Rust picked a simpler approach. Is it simply a first step to a more abstract approach?
In SIMD Everywhere Optimization from ARM Neon to RISC-V Vector Extensions
A problem is that most such things (the rust thing, C++'s experimental/simd, Zig's SIMD types) have the vector size as a compile-time property, while ARM's SVE and RISC-V's RVV are designed such that it's possible to write portable code that can work for a range of implementation widths. Thus such a fixed-width SIMD library would be forced to target the minimum (128-bit) even if the hardware supports 256-bit, 512-bit, or more. (SVE supports up to 1024-bit, RVV - up to 65536-bit) There is Highway (https://github.com/google/highway) however, that does support dynamically-sized SIMD.
In SIMD Everywhere Optimization from ARM Neon to RISC-V Vector Extensions
> does not run on the GPU both Cuda and the Metal shader language are C++, so is OpenCL since 2.0 (https://www.khronos.org/opencl/), so is AMD ROCm's HIP (https://github.com/ROCm-Developer-Tools/HIP), so is SYCL (https://www.khronos.org/sycl/)? C++ is pretty much the language that runs most on GPUs. > no vector instructions, There's a thousand different possibilities for SIMD in C++, from #pragma omp simd, to libs such as std::experimental::simd (https://en.cppreference.com/w/cpp/experimental/simd/simd), Eve (https://github.com/jfalcou/eve), Highway (https://github.com/google/highway), Vc (https://github.com/VcDevel/Vc)...
In Stable Diffusion in C/C++
(Frequent AVX-512 user, opinions are my own.) It is time to stop quoting this rant, which is rather far removed from actual practice and reality. Specifically for sorting, Intel's sort and ours can be about 10x as fast as scalar. AVX-512 has high power? Great! Power is work per time. Let's have more of that. It is _useful_ work per _energy spent_ that we want to maximize, and there scalar code falls flat. Consider that OoO scheduling/control overhead is the real culprit; executing one instruction costs far more energy than the actual operation. SIMD divides that fixed cost over 16 elements, leading to 5-10x higher power efficiency. Top frequency reduction? Not since the first implementation on Skylake, and even there a non-issue, see https://github.com/google/highway/blob/master/hwy/contrib/so.... More cores? The shared-memory fabric is a
Read the rest
lready bursting at the seams (see on-chip bottlenecks of Genoa), we are already cramming in too many for the current memory interface. What would actually be necessary: more bandwidth! A64FX CPUs actually beat GPUs in 2019 for supercomputing applications thanks to their HBM. Intel's Sappire Rapids Max also has this. Let's build more of those, at a decent price. And start using the wide vector units, they are there precisely because lots of highly-clocked cores in one big NUMA domain is not always the best way forward.
In Intel Releases x86-SIMD-sort 2.0 With Faster AVX-512 Sorting, New Algorithms

Showing the 15 most recent of 30 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.