-
Monday, July 13, 2026 - Thursday, October 15, 2026
Roadside Recognition Using HLS Hackathon
Build the most energy-efficient inferencing accelerator for edge devices in this 30-day challenge, where victory goes to the team achieving the lowest energy per inference. Whether you prioritize maximum speed, ultra-low power consumption, or find the perfect balance, you'll need to meet strict accuracy and area requirements to claim exclusive prizes.
-
Tuesday, November 10, 2026
Webinar: Turning Shift-Left from Slogan to Reality
This webinar will show that SystemC models built with the open-source Matchlib library and synthesized with Catapult HLS close the gap between early design needs and late-arriving RTL. Such models exist early, simulate 30x–100x faster than RTL, are throughput-accurate with respect to the final implementation, and are the actual source from which the RTL is generated. Combined with a user-visible scheduling contract backed by formal proofs, they let most design, verification, and architectural exploration move to the source model. The same properties make this flow the natural foundation for the AI-driven design and verification flows now emerging.
-
Explore learning topics
-
AI/ML Accelerators and Design
Machine learning algorithms are ideal for implementation using High-Level Synthesis (HLS), as they are both computationally complex and highly parallel. These workloads often underperform on general-purpose CPUs. HLS empowers designers to explore and optimize architectures for AI/ML accelerators, enabling the creation of custom solutions that can significantly outperform general-purpose accelerators like GPUs or TPUs by an order of magnitude or more. -
Arithmetic Functions
Arithmetic functions are a vital part of High-Level Synthesis (HLS), especially in designs that involve intensive mathematical computations. Whether targeting FPGA or ASIC platforms, arithmetic operations are central across application domains. These arithmetic functions can be as simple as the basic operators such as adders, multipliers, dividers; to more complicated functions such as trigonometric functions, squares, roots, exponents, logarithms. On FPGAs, these are typically mapped to DSP blocks and LUTs, while in ASIC designs, they are implemented using standard cell libraries optimized for the target technology node. -
C++ Modeling
High Level Synthesis (HLS) designs leverage untimed C++ programming for efficient hardware modeling, offering streamlined coding practices and superior simulation performance. This approach enables developers to model hardware blocks through C++ classes, while managing design hierarchy and interconnections via class function calls. The implementation supports both fixed-point and floating-point datatypes, ensuring accurate modeling of numerical precision, saturation, and rounding operations. Comprehensive C++ libraries enhance HLS capabilities by providing ready-to-use components for mathematical operations, DSP functionalities, and various hardware-specific implementations, streamlining the hardware design workflow. -
Channels and Bus Interfaces
In High-Level Synthesis (HLS), channels are used to model data streaming interfaces and simplify system design and synthesis. Channels serve as flexible, FIFO-based connections between blocks, supporting any data type and enabling reliable data transfer in the correct order. This ensures streaming behavior in hardware can be accurately modeled and synthesized. Channels also help manage mismatched data rates between blocks and maintains consistency between simulation and synthesis. By enabling support for various bus protocols, channels provide bus interface behavior, allowing for streamlined integration of control signals, data, and synchronization in complex, hierarchical systems. -
Control Logic and FSM
High-Level Synthesis (HLS) automatically generates control logic and finite state machines (FSM) to optimize digital circuit design. The control logic manages data movement, pipeline stages, and resource sharing, while the FSM handles state transitions and operation sequencing in the data path. This powerful combination streamlines hardware design by efficiently managing operations and dependencies. Through advanced techniques like loop unrolling and pipelining, HLS enables engineers to convert high-level algorithms into optimized hardware implementations, enhancing overall circuit performance and efficiency. The system effectively handles conditional statements and loop structures, making it essential for modern digital circuit optimization and hardware design workflows. -
Data Types
Bit-accurate data types offer a reliable mechanism to model exact hardware bit-widths and arithmetic precision in High-Level Synthesis (HLS) workflows. These types range from simple signed and unsigned integer representations, familiar to RTL designers, to fixed point data types with support for rounding and saturation modes, and even fully IEEE-compliant floating-point types with user-defined exponent and mantissa widths. This level of control ensures bit-exact behavior, maintaining alignment between C++/SystemC numerical models and the final RTL generated by the HLS tool.Some organizations use proprietary or custom-developed bit-accurate types for modeling. However, two widely available open-source options are AC types and SystemC types they support robust C++/SystemC design styles and offer comprehensive integer and fixed-point modeling capabilities. AC Types have become especially popular due to their support for unlimited bit-length, consistent simulation semantics, and faster execution performance in compiled environments. -
Datapath
In hardware, an input data traverses through muxes, arithmetic and logic circuits to provide the output data. This path of traversal or this collection of functional units is called Datapath, and this represents the functional behavior of what the designer intended to do.In High-Level Synthesis (HLS), the Datapath operations are initially allocated from the selected FPGA or ASIC design library and then scheduled based on the clock period, registering where required into different clock steps with the help of a Finite State Machine. Datapath contains information of data flow or in other words – “data dependencies”. The hardware datapath captures critical data dependencies, which must be managed to avoid feedback issues during RTL generation. Accurate clock scheduling and hardware optimization make the datapath one of the most essential elements in any HLS-driven digital design. -
Design Partitioning
Design partitioning is a powerful technique that enables designers to manage complexity more effectively and optimize distinct elements of a system for improved performance and reuse. By logically grouping mutually exclusive functions or operators, partitioning allows better control over resource sharing and optimization strategies.Partitions can be combinational, supporting simpler logic clusters, or sequential, incorporating pipelined datapath elements to meet higher frequency targets or accommodate a larger number of operators. Thoughtful design partitioning helps maintain clarity, scalability, and efficiency across complex hardware systems. -
HLS 101
High-Level Synthesis (HLS) is a design methodology that raises the abstraction level above traditional Register-Transfer Level (RTL) by starting with a C++ or SystemC description of a digital system. The methodology also incorporates trusted verification tools and techniques to ensure that the design is synthesizable and that both the original high-level description and resulting RTL meet the target specification. The resulting RTL can then be verified, synthesized into a netlist, and physically laid out using traditional tool flows.For hardware design, HLS and verification (High-Level Verification - HLV), there are considerable advantages to using this methodology to deliver high quality RTL, be it VHDL or Verilog. HLS is a critical approach to addressing the rising complexity of today’s digital systems. Designers can evaluate numerous architectural alternatives to find the best power, performance, and area in half the time with a fraction of the engineering resources of traditional RTL flows. At the same time, HLS enables orders of magnitude improvements in design verification and reliability. -
HLS FPGA
Achieving optimal algorithmic implementation using High-Level Synthesis (HLS) tools for FPGA development requires deep understanding of FPGA architecture and its capabilities. Modern FPGA devices offer sophisticated hardware resources that HLS tools can leverage, including specialized blocks like Block RAMs, DSP slices, and configurable shift registers. Leading FPGA vendors provide diverse configuration options through their HLS tools, supporting features such as true dual-port and simple dual-port memories, synchronous and asynchronous operational modes, and comprehensive arithmetic capabilities spanning both floating-point and fixed-point implementations. HLS FPGA tools enable efficient pipeline optimization through multiple register stages, allowing designers to fine-tune performance. When selecting an FPGA platform for HLS implementation, it's crucial to evaluate device-specific features, resource availability, and architectural advantages that align with design requirements. This strategic approach to FPGA selection and HLS tool utilization ensures optimal performance, resource utilization, and design efficiency in the final hardware implementation. -
Hierarchy
Hierarchy is a fundamental concept in both Register Transfer Level (RTL) and High-Level Synthesis (HLS) for managing design complexity, promoting modular design, and enabling IP reuse. In SystemC, hierarchy is defined explicitly using SC_MODULE constructs that clearly specify interfaces, along with clock and reset signals. In C++-based HLS, hierarchy and parallelism are modeled implicitly and later transformed into an explicit RTL structure, ensuring accurate, efficient hardware implementation. -
High-Level Static and Formal Verification
Sequential Logic Equivalence Checking (SLEC) and Formal Verification techniques provide robust validation for High-Level Synthesis (HLS) C-source designs. This comprehensive verification framework integrates advanced formal analysis methods. The C-Level verification suite combines simulation capabilities, coverage metrics, and formal property verification, mirroring established RTL design flows while operating at a higher abstraction level. Through formal proof techniques, designers can leverage assertions, coverage analysis, and reachability studies to validate design behavior systematically. The integration of formal methods with HLS enables automated proof of functional equivalence between high-level specifications and RTL implementations, while property checking ensures comprehensive verification closure. This powerful combination of static analysis and formal verification methodologies helps teams achieve thorough design validation and efficient coverage closure, significantly reducing verification cycles. -
High-Level Verification
High-Level Verification (HLV) is the application of known and trusted verification techniques to High Level Synthesis (HLS) design source. This advanced approach delivers remarkable performance gains, as simulations run at speeds up to 30, 100 or even up to 500x faster than comparable RTL simulations. HLV integrates seamlessly with established Design Verification (DV) methodologies, incorporating metrics-driven code coverage, functional coverage closure, and comprehensive test plan integration. The framework employs both dynamic and static verification techniques, including thorough lint checks and deep formal property verification, all executed before RTL generation. By implementing rigorous ASIC-quality signoff procedures at the HLS source level, HLV effectively prevents bug escapes into RTL while enabling efficient verification reuse during post-HLS RTL sign-off phases. This comprehensive verification strategy ensures robust design quality and accelerates the overall development cycle. -
IP
High-Level Synthesis (HLS) IP cores are soft IP cores but in the form of a high-level language instead of RTL languages. They are generally present as C/C++, SystemC. -
Image/Video Processors and Design
The future of image and video processing is here, powering deepfakes, self-driving cars, and virtual reality. These innovations all stem from the fundamentals of digital signal processing. With modern AI now recognizing and generating images, the demand for high-performance image and video processors is growing. High-Level Synthesis (HLS) plays a key role in designing efficient, custom solutions for these applications. This page explores the basics of image and video processing and how HLS helps bring the next-generation of visual technologies to life. -
Loop Unrolling
Loop unrolling is a fundamental optimization technique for driving parallelsim in High-Level Synthesis (HLS). By replicating loop bodies, loop unrolling enables multiple operations to execute concurrently, accelerating critical design paths. However, designers should recognize that inter-iteration dependencies can constrain full parallelism, even when a loop is partially or fully unrolled. -
MathWorks
MATLAB and Simulink integrate into the High-Level Synthesis (HLS) design flow to enable a seamless algorithm-to-RTL process with continuous verification. The workflow begins with algorithm development in MATLAB or Simulink, where floating-point models are created and validated. These models are then translated into C++ for High-Level Synthesis.Crucially, the C++ models generated for HLS are folded back into the original MATLAB or Simulink testbenches, enabling system-level verification against the algorithmic reference. As the C++ model is refined for synthesis, it remains testable within the MathWorks environment using the High-Level Verification (HLV) framework. HLV provides model instrumentation and coverage analysis directly within the MATLAB testbench, helping improve DUT quality and the effectiveness of stimuli for subsequent RTL verification.This integrated approach connects algorithm development, High-Level Synthesis, and RTL verification into a unified flow, ensuring consistent validation from model to implementation. -
Memories
Types of Memories in High-Level Synthesis (HLS) include Single Port RAM, Read Only Memory (ROM), First In First Out (FIFO), and True Dual Port RAM. These storage components are mapped from arrays in HLS C++ based on their size and usage, implemented as block RAM, distributed RAM, registers, and FIFOs. The necessary addresses, data, and control signals needed to access the memories are automatically created. Several pre-built FPGA and ASIC memory libraries are included in HLS for the supported technologies, featuring user-defined latency to add register banks to the input and output of the memories and configurable Read/Write Resolutions where supported. In addition to these memory libraries, custom memory libraries can be generated using a Memory Generator in HLS, which allows users to read in VHDL or Verilog models of memory and generate vendor-specific custom memory libraries. This utility is particularly useful for creating ASIC memories from IP groups or foundries. -
Open-Source Foundation Libraries for HLS
The High-Level Synthesis (HLS) Foundation Libraries represent a powerful open-source initiative implemented in standard C++, enabling precise bit-accurate hardware and software design. These comprehensive libraries serve as a catalyst for hardware acceleration, offering robust, synthesizable building blocks for both FPGA and ASIC implementations. The goal of these libraries is to create an open community for exchange of knowledge and IP for HLS that can be used to accelerate both research and design. These libraries are delivered as an open-source project on GitHub under the Apache 2.0 license and contributions are welcome. Whether you're working on academic research or industrial applications, these libraries provide the essential building blocks for efficient hardware design and implementation. -
Pipelining
Pipelining means how often to start (the next) iteration of a loop or a function in High-Level Synthesis (HLS). It is defined with an Initiation Interval (II). The default II is generally 1, often implying continuous clock-by-clock throughput and minimal latency. However, in some cases, an Initiation Interval greater than one may be used, which can increase latency and is often due to resource constraints, feedback dependencies, or memory competition. -
Processor Accelerators
High-Level Synthesis (HLS) enables developers to create domain-specific process accelerators to achieve higher performance and greater efficiency. As silicon scaling no longer delivers these gains, offloading complex algorithms from general-purpose processors to dedicated hardware accelerators improves performance, reduces power and cost, and optimizes area. This shift also can allow for the use of smaller, more efficient processors. HLS makes this transition fast and easy, while minimizing execution and scheduling risks. -
SystemC Modeling
Using SystemC to model High-Level Synthesis (HLS) designs enables a wide range of hardware design types to be modeled and efficiently verified before HLS. SystemC enables comprehensive hardware aspects to be modeled, including modules and module hierarchy, ports, signals, concurrent processes, reset signals, and precise timing control. All major HDL simulators support simulation of mixed testbench and design hierarchies that seamlessly integrate SystemC, SystemVerilog, and VHDL modules for complete design verification. Within SystemC HLS models, libraries such as MatchLib facilitate transaction interfaces and provide essential building block IP models. These models leverage both fixed-point and floating-point datatypes to accurately represent limited numerical precision, saturation, and rounding operations. The extensive C++ libraries for HLS empower designers to model complex math functions, DSP operations, and various hardware functionalities, making SystemC a powerful solution for modern hardware design workflows.
-
-
Recently published in HLS Academy
Filters
-
Making shift-left real: Why SystemC, MatchLib, and High-Level Synthesis are the right foundation for SoC design and verification in an age of AI
SystemC Modeling Oct 06, 2026 Paper -
-
Verifying Hardware at the Source: Why a User-Visible HLS Scheduling Contract Matters in an Age of AI-Generated Design
SystemC Modeling Aug 14, 2026 Paper -
-
-
-
-
-
What We Offer
-
A community of industry peers
The HLS Community is eager to answer your questions! We encourage you to take an active role in the Forums by posting, answering, and commenting to questions that pique your interest.
-
In-depth learning resources
We offer users multiple entry points to find the information they need. One of these entry points is through our resources. Find resources to learn more about topics you care about.
-
-
What & Who we are
-
What is High-Level Synthesis
Learn MoreHigh-Level Synthesis (HLS) is a design methodology that begins with a C++ or SystemC description of a digital system and then automatically translates and optimizes the design into an RTL implementation. The methodology also incorporates trusted verification tools and techniques to ensure that the design is synthesizable and that both the original high-level description and resulting RTL meet the target specification. The resulting RTL can then be verified, synthesized into a netlist, and physically laid out using traditional tool flows.
HLS is a critical approach to addressing the rising complexity of today’s digital systems. Designers can evaluate numerous architectural alternatives to find the best power, performance, and area in half the time with a fraction of the engineering resources of traditional RTL flows. At the same time, HLS enables orders of magnitude improvements in design verification and reliability.
-
Who we are
Learn MoreWelcome to the HLS Academy, a platform designed to help you develop the skills necessary to advance your organization's high-level design and synthesis processes. Our team comprises subject-matter experts in the industry dedicated to providing the necessary skills to mature an organization’s advanced HLS capabilities.
We provide a practical approach to learning the core principles of using C++ and SystemC to describe your design and apply High-Level Synthesis and Verification tools to realize the full benefits of this advanced methodology.
HLS Academy provides a wealth of resources, events, and tools to help design engineers stay up-to-date with the latest trends and techniques in the field.
-
-