What Is an FPGA IP Core? Using and Developing IP

/ Ecem Uçar / FPGA Design Engineer
#FPGA#IPCore
What Is an FPGA IP Core? Using and Developing IP

Designing an FPGA-based system from scratch does not mean writing every module at the RTL level. In real projects, engineers meet most of the functionality they need from ready-made IP (Intellectual Property) blocks. These blocks are verified, reusable hardware modules: a FIFO, a UART controller, an FFT engine, or a PCIe interface. The IP Core concept is the fundamental building block of FPGA development and directly affects both the speed and reliability of a project.

In this article, we will cover what an IP Core is, its types, how it is used, and the basic steps of developing your own IP.

What Is an IP Core?

An IP Core (Intellectual Property Core) is a pre-designed and verified hardware module that performs a specific function. Similar to the concept of a library in software, IP Cores are integrated into a project and can be used repeatedly. The difference is that these blocks operate at the hardware level and are synthesized and placed onto the FPGA fabric.

An IP Core can consist of a single gate, or it can be a complex processor subsystem. For example, the MicroBlaze processor core in the AMD IP catalog is a complete soft processor on its own, composed of hundreds of submodules. On the other hand, a simple AXI GPIO block consists of just a few registers and interface logic.

The fundamental motivation for using IP Cores is clear: instead of writing a UART from scratch for every project, integrating a verified UART IP saves time and reduces the risk of errors.

IP Core Types: Soft, Firm, and Hard

IP Cores are divided into three main categories based on their delivery format and flexibility level:

Soft IP

Delivered as RTL source code, in VHDL or Verilog format. The user can view, modify, and synthesize it for different FPGA families. Flexibility is at the highest level, but there is no performance guarantee; the result depends on the synthesis tool and the target FPGA’s capacity. The vast majority of open-source IPs fall into this category.

Firm IP

Delivered in synthesized netlist format. The logic structure is determined but physical placement has not yet been done. The source code is not visible, therefore modifications cannot be made. However, it can be ported to different models within the same FPGA family. Performance is more predictable compared to Soft IP.

At RunX, we develop and offer essential communication and data transfer IP Cores commonly needed in FPGA projects. Our portfolio includes UART Controller, SPI Master/Slave, SPI Flash Controller, I2C Master, and DMA/VDMA IP Cores. All of our IPs are AXI-compatible, vendor-independent, and ready for immediate integration. Visit IP Cores for details for project-specific solutions. Our IP development process is actively ongoing. We can design and develop custom IP Cores tailored to your specific needs. Simply contact us to get started.

Hard IP

These are blocks whose physical layout is complete and fixed onto the silicon. They are embedded into the FPGA chip during the manufacturing stage and cannot be modified by the user. The ARM Cortex-A53 processor cores, DDR controller, and PCIe blocks on the Zynq UltraScale+ are examples. They offer the highest performance and lowest power consumption, but flexibility is zero.

ip types ip types

Where to Find IP Cores?

In FPGA development, IP Cores can be accessed through three main channels:

Vendor IP Catalogs

AMD (Xilinx) and Intel (Altera) offer comprehensive IP catalogs integrated into their tools (Vivado, Quartus). These catalogs include AXI interface blocks, memory controllers, DSP modules, communication protocols (Ethernet MAC, PCIe, SPI, I2C), and more. Vendor IPs are optimized for the target FPGA family and are generally free of charge.

Third-Party IP Providers

Companies offering specialized functions (Synopsys, Cadence, Northwest Logic, etc.) sell IP blocks under commercial licenses. These IPs are typically complex modules such as high-performance memory controllers, video codecs, and encryption engines. The licensing model may vary per project, per production, or per chip.

Open-Source IPs

IP Cores developed by the community can be found on platforms such as OpenCores, LibreCores, and GitHub. UART, SPI, I2C, Wishbone interfaces, and simple processor cores are among the most common. Open-source IPs are free, but their verification level is uncertain. Thorough testing should be performed before using them in production.

find ip find ip

How to Use an IP Core?

IP Core integration varies depending on the development environment, but the basic steps are common:

  1. Selecting the block from the IP catalog or an external source
  2. Configuring parameters (data width, clock frequency, FIFO depth, etc.)
  3. Establishing interface connections (AXI, AXI-Stream, Wishbone, or custom ports)
  4. Connecting clock and reset signals
  5. Synthesis, implementation, and verification

In the Vivado environment, this process is largely carried out through the graphical interface (IP Integrator / Block Design). You place IP blocks onto the block design via drag-and-drop and draw the connections. The tool automatically detects incompatible interface widths or missing clock connections.

However, IP Integrator is not always sufficient. When customized data paths, special timing requirements, or functions not available in the catalog are needed, you must develop your own IP Core.

integration integration

Developing Your Own IP Core

Developing a custom IP is one of the most valuable skills in FPGA engineering. It means solving a need that ready-made IPs cannot meet (such as a custom filter, sensor interface, or protocol converter) at the hardware level.

Design Flow

  1. Requirements definition: Define what the IP will do, its input/output ports, timing requirements, and target resource budget.
  2. Interface selection: Decide how the IP will connect to the system. AXI4-Lite is suitable for control registers, AXI4-Stream for continuous data flow, and Memory-Mapped for addressable memory access.
  3. RTL coding: Write your module in VHDL or Verilog.
  4. Simulation and verification: Perform functional verification with a testbench. Test corner cases, clock domain crossings, and reset behavior.
  5. Packaging: Using the “Create and Package New IP” wizard in Vivado, you can convert your IP into catalog format. In this step, AXI interfaces, register maps, and driver files can be generated automatically.
  6. Integration and test: You can add the packaged IP to Block Design, connect it with other blocks, and verify the entire system on hardware.
custom ip custom ip

Key Considerations in IP Development

Resource utilization: Every IP Core consumes LUT, FF, BRAM, and DSP resources on the FPGA. Planning the resource budget from the start is critical, especially on smaller FPGAs. Check synthesis reports regularly.

Clock domain crossings: When transferring data between IPs operating at different clock frequencies, metastability risk arises. Techniques such as asynchronous FIFOs or dual-register synchronization should be used.

Timing closure: Verify whether your IP operates at the target clock frequency from post-implementation timing reports. Setup and hold violations can lead to unpredictable errors in the field.

Documentation: An IP without a register map, timing diagrams, and an integration guide cannot be reused. Create the documentation alongside the IP packaging.

Licensing: If you are using commercial IP, clarify the licensing terms upfront. Some IPs are free only during the development phase; per-device or royalty models come into effect at production. For open-source IPs, pay attention to the license type (MIT, GPL, LGPL). A GPL-licensed IP may require you to open-source your entire project.


IP Cores are the most powerful accelerator in FPGA development. A correctly selected and properly integrated IP block reduces weeks of RTL work to a few hours. However, every IP also adds a dependency to the project: resource consumption, licensing restrictions, and update requirements should not be overlooked.

Developing your own IP Core where ready-made IPs fall short gives you full control over your design. A Custom IP that complies with AXI interface standards, is well documented, and thoroughly verified accelerates not only the current project but future projects as well.

For verified, AXI-compatible IP Cores ready to integrate into your projects, visit IP Cores or contact our team for custom solutions.

Share this article: