Agent skill

Vitis Hls Synthesis

by Shinei-Nouzen-Arch in Shinei-Nouzen-Arch/FPGA-Agent

Vitis HLS synthesis assistant for C/C++ to RTL conversion. An agent skill from Shinei-Nouzen-Arch/FPGA-Agent.

GPL-2.0Auto-check passedDevelopment

Install Vitis Hls Synthesis

skills CLI
$ npx skills add Shinei-Nouzen-Arch/FPGA-Agent --skill vitis-hls-synthesis -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Shinei-Nouzen-Arch/FPGA-Agent vitis-hls-synthesis --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Shinei-Nouzen-Arch/FPGA-Agent.git skills-src && mkdir -p .claude/skills && cp -r skills-src/vitis-hls-synthesis .claude/skills/vitis-hls-synthesis && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
vitis-hls-synthesis
GitHub stars
180
Token cost
~1.8k tokens
SKILL.md length
655 words
Files
1,076
Skills in repo
10
Repo updated
First seen
Licence
GPL-2.0

At a glance

Vitis HLS synthesis assistant for C/C++ to RTL conversion. An agent skill from Shinei-Nouzen-Arch/FPGA-Agent.

  • Works in 10 steps: Project Initialization → Code Development → Configuration File → …
  • Development work in your project
  • SKILL.md covers When to Use This Skill, Workflow, Quick Reference and Common Scenario Examples, plus 1 more section
  • Runs Python scripts from its folder

What it does

Vitis Hls Synthesis is an agent skill from Shinei-Nouzen-Arch/FPGA-Agent. Vitis HLS synthesis assistant for C/C++ to RTL conversion. Covers kernel development, pragma optimization, interface configuration, and synthesis report analysis. For post-synthesis implementation use vivado-impl, for timing analysis use vivado-analysis, for hardware debug use vivado-debug.

Its SKILL.md is about 1.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 1081 other files (for example `REFERENCE.md`, `agents/openai.yaml` and `examples/Design_Tutorials/02-Beamformer/README.md`).

It sits in Development. It works with C++. The licence is GPL-2.0.

When your agent uses it

  • Development work in your project

Example prompts

  • “/vitis-hls-synthesis”

Requirements

  • Python 3

Workflow steps

10 steps, taken from the step headings in SKILL.md.

  1. Project Initialization
  2. Code Development
  3. Configuration File
  4. Run Flow
  5. Report Analysis
  6. Pipeline Optimization Kernel
  7. Array Partition Optimization
  8. Dataflow Task Parallelism
  9. AXI4-Stream Interface
  10. Fixed-Point Conversion

What it can do on your machine

Read from SKILL.md and the folder at commit b60a52e. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships script files (Python, from the files we listed), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Vitis Hls Synthesis loads about 1.8k tokens when it runs. Until then it costs about 78 tokens; SKILL.md has 655 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~78
When it runs · the whole SKILL.md, loaded when a task matches
~1.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Shinei-Nouzen-Arch/FPGA-Agent at commit b60a52e, republished under its GPL-2.0 licence (© Shinei-Nouzen-Arch). 655 words, ~1,820 tokens.

Download SKILL.mdSave it as .claude/skills/vitis-hls-synthesis/SKILL.md (or your agent's skills folder). This skill also uses 1075 other files; get the full folder from GitHub.
name
vitis-hls-synthesis
description
Vitis HLS synthesis assistant for C/C++ to RTL conversion. Covers kernel development, pragma optimization, interface configuration, and synthesis report analysis. For post-synthesis implementation use vivado-impl, for timing analysis use vivado-analysis, for hardware debug use vivado-debug.

Vitis HLS Synthesis Development Assistant

This skill helps you efficiently perform FPGA high-level synthesis development in the Vitis HLS environment. For complete syntax reference, see REFERENCE.md.

When to Use This Skill

  • Need to write or optimize C/C++ HLS kernel code
  • Need to add pragma optimization instructions (pipeline, unroll, dataflow, array_partition, etc.)
  • Need to configure synthesis constraint files (.cfg)
  • Need to run Vitis HLS synthesis commands
  • Need to analyze synthesis reports (timing, resource, II value)
  • Need to configure interface protocols (AXI4-Stream, M_AXI, s_axilite, etc.)
  • Need to select appropriate data types (arbitrary precision types, HLS-specific types)
  • Need to optimize DDR access and HBM bandwidth

Workflow

Select only the stages needed for the requested outcome and reuse the existing project and results. Report interpretation does not require project initialization or a new build. Code or configuration changes include proportionate validation; an execution request includes the requested run stages and result checks. Generate or review scripts without executing them when that is the requested deliverable. Existing authorization covers necessary in-scope follow-up, but does not automatically extend the task to packaging, implementation, or hardware programming.

1. Project Initialization

When initialization is needed, determine the project structure and target device from existing sources, configuration, and prior user instructions. Reuse established settings and create only missing directories. Ask only for consequential information that is unavailable; never guess a device or clock required for a run. A generic example can retain clearly marked parameters without blocking on device selection.

bash
mkdir -p <project>/src <project>/tb
2. Code Development

Write HLS kernel code, add pragma optimization instructions as needed, select appropriate data types and interface protocols.

3. Configuration File

Create or update the relevant .cfg file, preserving established device, clock, interface, and flow settings unless changing them is part of the request.

4. Run Flow

For execution requests, run the applicable stages and their prerequisites:

  1. C simulation to verify functional correctness
  2. C synthesis to generate RTL
  3. C/RTL co-simulation to verify hardware functionality
  4. Export IP or Vitis kernel when packaging is part of the requested deliverable
5. Report Analysis

Check the status, relevant logs, and outputs of each requested stage. Use simulation results to assess tested functionality and HLS synthesis estimates to assess clock performance, II, latency, and resources against the stated requirements. HLS estimates are not post-route timing signoff; apply the Vivado timing acceptance criteria only when implementation is in scope. Report what was verified, what remains unverified, and the requested artifact locations. Continue necessary authorized work rather than treating report generation or a partial run as completion.

Show full SKILL.md (238 more words)Show less

Quick Reference

Core Commands
TaskCommand
Environment Setupsource <Vitis_dir>/settings64.sh
Synthesisv++ -c --mode hls --config <config.cfg>
C Simulationvitis-run --mode hls --csim --config <config.cfg>
Synthesisvitis-run --mode hls --csynth --config <config.cfg>
Co-Simulationvitis-run --mode hls --cosim --config <config.cfg>
Export IPvitis-run --mode hls --package --config <config.cfg>
Common Pragmas
Optimization TypeInstruction Example
Pipeline#pragma HLS PIPELINE II=1
Loop Unroll#pragma HLS UNROLL factor=4
Array Partition#pragma HLS ARRAY_PARTITION variable=arr type=cyclic factor=2
Dataflow#pragma HLS DATAFLOW
Interface Configuration#pragma HLS INTERFACE mode=m_axi port=mem bundle=gmem
Core Configuration Parameters
ParameterDescription
part=<part_number>Target device model
clock=<ns>Clock period (ns)
flow_target=<vivado/vitis>Target output type
syn.top=<function_name>Top-level function name
syn.file=<source_file>Source file path

For complete syntax and parameter reference, see REFERENCE.md. Reference implementation examples are available in the examples/ directory - read these files first when users need coding patterns or best practices.

Common Scenario Examples

1. Pipeline Optimization Kernel

Add pipeline optimization to loops to achieve II=1:

cpp
void kernel(float A[32][32], float B[32][32], float C[32][32]) {
    #pragma HLS INTERFACE m_axi port=A bundle=gmem
    #pragma HLS INTERFACE m_axi port=B bundle=gmem
    #pragma HLS INTERFACE m_axi port=C bundle=gmem

    for (int i = 0; i < 32; i++) {
        for (int j = 0; j < 32; j++) {
            #pragma HLS PIPELINE II=1
            float sum = 0;
            for (int k = 0; k < 32; k++) {
                sum += A[i][k] * B[k][j];
            }
            C[i][j] = sum;
        }
    }
}
2. Array Partition Optimization

Partition arrays to improve parallel access:

cpp
#pragma HLS ARRAY_PARTITION variable=input_data type=cyclic factor=4 dim=1
#pragma HLS ARRAY_PARTITION variable=weights type=complete dim=1
3. Dataflow Task Parallelism

Implement multi-stage task parallelism:

cpp
void top(hls::stream<int> &in, hls::stream<int> &out) {
    #pragma HLS DATAFLOW
    hls::stream<int> fifo1, fifo2;
    #pragma HLS STREAM variable=fifo1 depth=16
    #pragma HLS STREAM variable=fifo2 depth=16

    read_image(in, fifo1);
    process_image(fifo1, fifo2);
    write_image(fifo2, out);
}
4. AXI4-Stream Interface

Implement AXI4-Stream input and output:

cpp
#include "hls_stream.h"

void axis_process(hls::stream<ap_int<32>> &in, hls::stream<ap_int<32>> &out) {
    #pragma HLS INTERFACE axis port=in
    #pragma HLS INTERFACE axis port=out
    #pragma HLS PIPELINE II=1

    ap_int<32> data = in.read();
    // Data processing
    out.write(data);
}
5. Fixed-Point Conversion

Convert floating-point to fixed-point for performance optimization:

cpp
#include "ap_fixed.h"
// ap_fixed<total_width, integer_bits, quantization_mode, overflow_mode>
typedef ap_fixed<16, 8, AP_RND, AP_SAT> fixed_t;
fixed_t value = 1.5f; // Automatic quantization
Post-Synthesis Flow
  • vivado-impl: Place and route optimization for HLS-generated IP
  • vivado-analysis: Timing report analysis and closure strategies
  • vivado-constraints: Add top-level timing and physical constraints
Simulation and Debug
  • vivado-sim: RTL functional and timing simulation
  • vivado-debug: ILA/VIO hardware debug configuration
Automation
  • vivado-tcl: HLS IP integration and project automation scripts

© Shinei-Nouzen-Arch, GPL-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1,075 other files in vitis-hls-synthesis of Shinei-Nouzen-Arch/FPGA-Agent.

  • SKILL.md
  • REFERENCE.md
  • agents/openai.yaml
  • examples/Design_Tutorials/02-Beamformer/Makefile
  • examples/Design_Tutorials/02-Beamformer/README.md
  • examples/Design_Tutorials/02-Beamformer/description.json
  • examples/Design_Tutorials/02-Beamformer/images/Beamformer.PNG
  • examples/Design_Tutorials/02-Beamformer/images/Development_Time.PNG
  • examples/Design_Tutorials/02-Beamformer/images/HLS_MATLAB_flow.png
  • examples/Design_Tutorials/02-Beamformer/images/Results_Versal.PNG
  • examples/Design_Tutorials/02-Beamformer/images/Results_Zynq.PNG
  • examples/Design_Tutorials/02-Beamformer/project.cfg
  • examples/Design_Tutorials/02-Beamformer/project.py
  • examples/Design_Tutorials/02-Beamformer/reference_files/mgs_qrd_wbs.cpp
  • examples/Design_Tutorials/02-Beamformer/reference_files/mgs_qrd_wbs.h
  • … and 1,061 more

Open the folder on GitHubat commit b60a52e

Compare with similar skills

Vitis Hls Synthesis next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Vitis Hls Synthesis compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Vitis Hls Synthesis this skillShinei-Nouzen-Arch/FPGA-Agent180—~1.8kAutomated safety check: PassGPL-2.0
Qt C++ Code Reviewx-tools-author/x-tools1.1k2 repos~4.3kAutomated safety check: PassBSD-3-Clause
YugabyteDB ASH Instrumentationyugabyte/yugabyte-db11k—~4.5kAutomated safety check: PassCustom licence
pybind11 Release Preparationpybind/pybind1118k—~1.7kAutomated safety check: PassCustom licence
Qt Cpp ReviewSerial-Studio/Serial-Studio7.2k—~4.3kAutomated safety check: PassCustom licence
Paddle Eager GraphPaddlePaddle/Paddle24k—~562Automated safety check: PassApache-2.0

Similar skills

  • Qt C++ Code Review

    x-tools-author/x-tools

    Read-only review of Qt6 C++ code that combines a deterministic lint script with six parallel analysis agents and reports only high-confidence issues.

    1.1k GitHub starsUsed in 2 repos~4.3k tokens
    DevelopmentAuto-check passed
  • YugabyteDB ASH Instrumentation

    yugabyte/yugabyte-db

    Procedure for adding or changing YugabyteDB Active Session History wait states in TServer and DocDB C++ code, including the macro to use for sync and async paths.

    11k GitHub stars~4.5k tokensUpdated today
    DevelopmentAuto-check passed
  • Opens the pybind11 release-preparation pull request: picking the release base, bumping the version in common.h and integrating the changelog, following docs/release.rst.

    18k GitHub stars~1.7k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Qt Cpp Review

    Serial-Studio/Serial-Studio

    Qt6/C++ deep code review for Serial Studio. An agent skill from Serial-Studio/Serial-Studio.

    7.2k GitHub stars~4.3k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Paddle Eager Graph

    PaddlePaddle/Paddle

    A skill your agent uses when navigating Paddle eager-mode (dynamic graph) source code, tracing forward/backward execution, debugging autograd issues, understanding PyLayer, or investigating…

    24k GitHub stars~562 tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Esp32 Firmware Engineer

    alxv2016/folloup-sticky

    ESP32 firmware engineering for ESP-IDF projects. An agent skill from alxv2016/folloup-sticky.

    117 GitHub starsUsed in 1 repo~3.8k tokens
    DevelopmentAuto-check passed

More from Shinei-Nouzen-Arch/FPGA-Agent

All 10 skills in this repo
  • Vivado Debug

    Shinei-Nouzen-Arch/FPGA-Agent

    A skill your agent uses when the user needs help with Vivado in-system debugging, hardware programming, or debug core configuration.

    180 GitHub stars~4.8k tokensUpdated 1 mo ago
    Auto-check passed
  • Vivado Analysis

    Shinei-Nouzen-Arch/FPGA-Agent

    A skill your agent uses when the user needs Vivado design analysis, timing report interpretation, or timing-closure diagnosis.

    180 GitHub stars~3.3k tokensUpdated 1 mo ago
    Auto-check passed
  • Vivado Constraints

    Shinei-Nouzen-Arch/FPGA-Agent

    A skill your agent uses when the user needs help writing XDC/SDC timing or physical constraints for Vivado FPGA designs.

    180 GitHub stars~3.4k tokensUpdated 1 mo ago
    Auto-check passed
  • Vivado Impl

    Shinei-Nouzen-Arch/FPGA-Agent

    A skill your agent uses when the user needs Vivado implementation strategy selection or optimization.

    180 GitHub stars~3.7k tokensUpdated 1 mo ago
    Auto-check passed
  • Vivado Sim

    Shinei-Nouzen-Arch/FPGA-Agent

    A skill your agent uses when the user needs help with Vivado simulation strategy, flow selection, and debugging.

    180 GitHub stars~2.9k tokensUpdated 1 mo ago
    Auto-check passed
  • Vivado Synth

    Shinei-Nouzen-Arch/FPGA-Agent

    A skill your agent uses when the user needs help with Vivado synthesis strategy selection, synthesis attribute configuration, synthdesign option tuning, resource inference control…

    180 GitHub stars~3.6k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Vitis Hls Synthesis

What does Vitis Hls Synthesis do?

Vitis HLS synthesis assistant for C/C++ to RTL conversion. An agent skill from Shinei-Nouzen-Arch/FPGA-Agent. Vitis Hls Synthesis is an agent skill from Shinei-Nouzen-Arch/FPGA-Agent. Vitis HLS synthesis assistant for C/C++ to RTL conversion.

When should I use Vitis Hls Synthesis?

Vitis Hls Synthesis fits situations like: development work in your project.

How do I install Vitis Hls Synthesis in Claude Code?

Run `npx skills add Shinei-Nouzen-Arch/FPGA-Agent --skill vitis-hls-synthesis -a claude-code`. Or copy the skill folder (vitis-hls-synthesis in Shinei-Nouzen-Arch/FPGA-Agent) into .claude/skills/vitis-hls-synthesis in your project. Claude Code loads it when a task matches its description.

How do I install Vitis Hls Synthesis in Codex?

Run `npx skills add Shinei-Nouzen-Arch/FPGA-Agent --skill vitis-hls-synthesis -a codex`. Or copy the skill folder (vitis-hls-synthesis in Shinei-Nouzen-Arch/FPGA-Agent) into .agents/skills/vitis-hls-synthesis in your project. Codex loads it when a task matches its description.

Can I use Vitis Hls Synthesis in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Shinei-Nouzen-Arch/FPGA-Agent --skill vitis-hls-synthesis -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/vitis-hls-synthesis, .gemini/skills/vitis-hls-synthesis, .github/skills/vitis-hls-synthesis and .opencode/skills/vitis-hls-synthesis in your project.

What does Vitis Hls Synthesis need to run?

Going by SKILL.md and its folder, Vitis Hls Synthesis needs Python for the scripts in its folder. Our summary lists: Python 3.

Does Vitis Hls Synthesis access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Vitis Hls Synthesis safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Vitis Hls Synthesis use?

Vitis Hls Synthesis is published under the GPL-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Vitis Hls Synthesis use?

About 1.8k tokens (SKILL.md is roughly 7.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Vitis Hls Synthesis?

Skills that share tags, products or a category with Vitis Hls Synthesis: Qt C++ Code Review (x-tools-author/x-tools, 1.1k stars), YugabyteDB ASH Instrumentation (yugabyte/yugabyte-db, 11k stars), pybind11 Release Preparation (pybind/pybind11, 18k stars) and Qt Cpp Review (Serial-Studio/Serial-Studio, 7.2k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Vitis Hls Synthesis?

Shinei-Nouzen-Arch (a GitHub user) maintains it in Shinei-Nouzen-Arch/FPGA-Agent, which has 180 GitHub stars. The repository holds 10 skills in this directory. The repository was last updated on September 5, 2026.

Source: Shinei-Nouzen-Arch/FPGA-Agent on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.