<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Home on HDL Factory Home</title>
    <link>https://www.hdlfactory.com/</link>
    <description>Recent content in Home on HDL Factory Home</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Sun, 19 Apr 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://www.hdlfactory.com/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Respin: upspin revival</title>
      <link>https://www.hdlfactory.com/post/2026/04/19/respin-upspin-revival/</link>
      <pubDate>Sun, 19 Apr 2026 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2026/04/19/respin-upspin-revival/</guid>
      <description>tl;dr: I revived the upspin project source code. See it at https://github.com/filmil/upspin, and https://github.com/filmil/upspin-gdrive. Read on to learn what that actually means.
 History Upspin was a project intended to provide a global namespace for all digital artifacts. It ended up mostly being used as a distributed file store, although the idea was more general than that. It was quite useful even as storage. And as far as distributed filesystems go, it was by far the simplest portable way to share storage between different machines.</description>
    </item>
    
    <item>
      <title>Synod: Paxos agent</title>
      <link>https://www.hdlfactory.com/post/2026/04/18/synod-paxos-agent/</link>
      <pubDate>Sat, 18 Apr 2026 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2026/04/18/synod-paxos-agent/</guid>
      <description>Find it at: https://github.com/filmil/synod
Synod is a distributed Paxos coordination agent implemented in Go. It manages a highly available, synchronized Key-Value store across a network of peers using the Paxos consensus algorithm. It allows multiple dynamically joining network nodes to agree on a shared state, ensuring fault tolerance and consistency across the cell.
 
Quickstart This quickstart shows how to download the repository and quickly start 3 synod agents which talk to each other and are already set up to work properly.</description>
    </item>
    
    <item>
      <title>mkill: a memory watchcat</title>
      <link>https://www.hdlfactory.com/post/2026/04/11/mkill-a-memory-watchcat/</link>
      <pubDate>Sat, 11 Apr 2026 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2026/04/11/mkill-a-memory-watchcat/</guid>
      <description>mkill is a Go program that continuously monitors memory usage of the programs owned by the current user. It kills the program with the sharpest rise in memory utilization when the overall system memory occupancy goes beyond the user-configured kill threshold. Download a binary release, or see the source code on Github.
 
I created mkill because I am handling some programs which tend to run away with memory use, in a setup which can not be easily sandboxed.</description>
    </item>
    
    <item>
      <title>Inventory of programmable hardware tooling</title>
      <link>https://www.hdlfactory.com/post/2026/02/01/inventory-of-programmable-hardware-tooling/</link>
      <pubDate>Sun, 01 Feb 2026 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2026/02/01/inventory-of-programmable-hardware-tooling/</guid>
      <description>A link page of interesting libraries and utilities I found.
Libraries, utilities, etc.  https://registry.bazel.build/modules/rules_verilator https://github.com/lromor/fpga-assembler https://registry.bazel.build/modules/yosys https://github.com/oxidecomputer/quartz https://github.com/corundum/corundum https://www.gaisler.com/grlib-ip-library https://surfer-project.org/ https://gitlab.arm.com/bazel/rules_patchelf  My stuff All available at: https://hdlfactory.com/bazel-registry/ if you are willing to use bazel.
 https://github.com/filmil/bazel_rules_nvc, builds NVC from source, fully hermetic. https://github.com/filmil/bazel_rules_ghdl, uses prebuilt GHDL, fully hermetic. https://github.com/filmil/bazel_rules_vivado, uses a prebuilt dockerized Vivado Fusesoc / edalize: https://github.com/filmil/bazel_rules_fusesoc_2, builds a hermetic fusesoc/edalize distribution from Python source. https://github.com/filmil/bazel_nvc_osvvm https://github.com/filmil/bazel_rules_vunit https://github.</description>
    </item>
    
    <item>
      <title>fshlib: shell library</title>
      <link>https://www.hdlfactory.com/post/2026/01/03/fshlib-shell-library/</link>
      <pubDate>Sat, 03 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2026/01/03/fshlib-shell-library/</guid>
      <description>fshlib fshlib is a simple shell library for logging. It provides a set of functions to log messages with different severity levels.
Github repo: https://github.com/filmil/fshlib
   
Usage To use the library, source the log.bash file in your script:
source &amp;quot;path/to/log.bash&amp;quot;  Then you can use the logging functions:
log::info &amp;quot;This is an info message&amp;quot; log::warn &amp;quot;This is a warning message&amp;quot; log::error &amp;quot;This is an error message&amp;quot;  Functions  log::info: Logs an informational message.</description>
    </item>
    
    <item>
      <title>note to self: do not remove `.bazelversion`</title>
      <link>https://www.hdlfactory.com/post/2025/12/20/note-to-self-do-not-remove-.bazelversion/</link>
      <pubDate>Sat, 20 Dec 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/12/20/note-to-self-do-not-remove-.bazelversion/</guid>
      <description>note to self: do not remove .bazelversion from projects The other day, I was pondering whether to keep setting particular bazel version in projects. I even removed some, to see what would become of it.
Since I use the bazelisk installation method, I get automatic bazel updates when a new version is released.
It turns out that this remains a bad idea. An auto-update to bazel 8.5.0 caused some of my CI workflows to fail, likely because bazel 8.</description>
    </item>
    
    <item>
      <title>rules_shar: bazel rules for creating self-extracting archives (shars)</title>
      <link>https://www.hdlfactory.com/post/2025/11/22/rules_shar-bazel-rules-for-creating-self-extracting-archives-shars/</link>
      <pubDate>Sat, 22 Nov 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/11/22/rules_shar-bazel-rules-for-creating-self-extracting-archives-shars/</guid>
      <description>This repository provides Bazel rules for creating self-extracting archives (&amp;ldquo;shar&amp;quot;s) out of shell binaries.
See section &amp;ldquo;what is this&amp;rdquo; below for details.
Details at: https://github.com/filmil/rules_shar
  
Usage To use the rules, add the following to your MODULE.bazel file:
bazel_dep(name = &amp;quot;rules_shar&amp;quot;, version = &amp;quot;0.0.0&amp;quot;) # Select your version, of course.  Then, in your BUILD.bazel file, you can use the shar_binary rule to create a self-extracting archive, as a drop-in replacement for the rule sh_binary.</description>
    </item>
    
    <item>
      <title>Hermetic, Ephemeral, Reproducible Builds: Take Three (3)</title>
      <link>https://www.hdlfactory.com/post/2025/10/29/hermetic-ephemeral-reproducible-builds-take-three-3/</link>
      <pubDate>Wed, 29 Oct 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/10/29/hermetic-ephemeral-reproducible-builds-take-three-3/</guid>
      <description>Bazel rules to support a debian rootfs The idea of this repository is to provide a hermetic, ephemeral and reproducible repository of prebuilt binaries, which can then be brought into bazel builds to remove the dependence on local binary installations.
 Find the project page at: https://github.com/filmil/bazel_debian_rootfs
    
This is otherwise a difficult task. Making a hermetic bazel build involves painstakingly bringing in each needed binary one at a time.</description>
    </item>
    
    <item>
      <title>Hermetic, Ephemeral, Reproducible Builds: Take Three (2)</title>
      <link>https://www.hdlfactory.com/post/2025/10/15/hermetic-ephemeral-reproducible-builds-take-three-2/</link>
      <pubDate>Wed, 15 Oct 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/10/15/hermetic-ephemeral-reproducible-builds-take-three-2/</guid>
      <description>This is another piece of news in my quest for hermetic, ephemeral, and reproducible builds (“HER”).
If you read my articles in the past months or so, you may have noticed that I am looking for good ways of creating completely hermetic, ephemeral, reproducible, but also practical builds.
Issues to solve The following is a list of issues with my previous HER build approaches:
I do not want to manage a software repository.</description>
    </item>
    
    <item>
      <title>Bazel knowledge sources</title>
      <link>https://www.hdlfactory.com/post/2025/10/07/bazel-knowledge-sources/</link>
      <pubDate>Tue, 07 Oct 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/10/07/bazel-knowledge-sources/</guid>
      <description>This is a collection of links to interesting articles and knowledge sources about the Bazel build system that I found.
I&amp;rsquo;m motivated to do this after spending considerable time developing a thing that already existed. Just because I was not following the &amp;ldquo;right&amp;rdquo; communities I basically wasted a lot of effort reinventing a wheel. Useful wheel, but reinventing nevertheless.
I plan to update the sources once in a while, as I discover things.</description>
    </item>
    
    <item>
      <title>Hermetic, Ephemeral, Reproducible Builds: Take Three (1)</title>
      <link>https://www.hdlfactory.com/post/2025/10/06/hermetic-ephemeral-reproducible-builds-take-three-1/</link>
      <pubDate>Mon, 06 Oct 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/10/06/hermetic-ephemeral-reproducible-builds-take-three-1/</guid>
      <description>This is another piece of news in my quest for hermetic, ephemeral, and reproducible builds (“HER”).
If you read my articles in the past months or so, you may have noticed that I am looking for good ways of creating completely hermetic, ephemeral, reproducible, but also practical builds.
In the past, I offered two approaches to HER builds that I believe take a stab at providing HER properties, while also remaining practical to everyday build engineers.</description>
    </item>
    
    <item>
      <title>Getting ready for the brave new Bazel Modules world</title>
      <link>https://www.hdlfactory.com/post/2025/09/29/getting-ready-for-the-brave-new-bazel-modules-world/</link>
      <pubDate>Mon, 29 Sep 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/09/29/getting-ready-for-the-brave-new-bazel-modules-world/</guid>
      <description>Update 2025-10-19: I made a searchable index of modules available from my registry at https://www.hdlfactory.com/bazel-registry.
 As Bazel 9.0 promises to disable the old dependency management approaches based on WORKSPACE by the end of 2025, I figured we should better start preparing. This is my preparation central.
Bazel modules promise to usher the era of trivial bazel dependency management. However, getting from here to there seems to be a journey fraught with peril.</description>
    </item>
    
    <item>
      <title>lit2md: a literate program converter from code to Markdown</title>
      <link>https://www.hdlfactory.com/post/2025/09/21/lit2md-a-literate-program-converter-from-code-to-markdown/</link>
      <pubDate>Sun, 21 Sep 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/09/21/lit2md-a-literate-program-converter-from-code-to-markdown/</guid>
      <description>lit2md: a literate program converter from code to Markdown lit2md is a simplistic literate programming (LP) converter.
See at: https://github.com/filmil/lit2md
It takes a source code file annotated with special &amp;ldquo;literate&amp;rdquo; programming comments, and outputs a markdown file in which the literate programming comments are converted into markdown text, and code is converted into code blocks.
Example For example, consider the simplistic hello.cc
//] # An example Hello World program. //] //] Don&#39;t forget headers!</description>
    </item>
    
    <item>
      <title>Writing XDC Clock Constraints for Vivado</title>
      <link>https://www.hdlfactory.com/post/2025/09/01/writing-xdc-clock-constraints-for-vivado/</link>
      <pubDate>Mon, 01 Sep 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/09/01/writing-xdc-clock-constraints-for-vivado/</guid>
      <description>Writing XDC Clock Constraints for Vivado This guide explains how to properly constrain a digital design with multiple clocks in an XDC (Xilinx Design Constraints) file, specifically for use in Vivado batch mode. We&amp;rsquo;ll cover primary clocks, generated clocks, and the relationships between them.
The Foundation: Primary Clocks A primary clock is a clock that enters the FPGA from an external source. It&amp;rsquo;s the root of a clock tree. You must define all primary clocks first.</description>
    </item>
    
    <item>
      <title>Decentralized Downloads for Bazel: Introducing `bazel_rules_bt`</title>
      <link>https://www.hdlfactory.com/post/2025/08/01/decentralized-downloads-for-bazel-introducing-bazel_rules_bt/</link>
      <pubDate>Fri, 01 Aug 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/08/01/decentralized-downloads-for-bazel-introducing-bazel_rules_bt/</guid>
      <description>Decentralized Downloads for Bazel: Introducing bazel_rules_bt In the world of reproducible builds and efficient dependency management, Bazel stands out as a powerful tool. However, fetching large or uncommon dependencies can sometimes be a bottleneck. Enter bazel_rules_bt, a set of Bazel rules that uses the BitTorrent protocol to bring decentralized file downloading capabilities directly into your build system.
 Find the project page at https://github.com/filmil/bazel_rules_bt
 The Power of Peer-to-Peer for Builds bazel_rules_bt addresses a common challenge: efficiently acquiring external files and archives that might be hosted on less reliable servers, or when you want to take advantage of peer-to-peer distribution for speed and resilience.</description>
    </item>
    
    <item>
      <title>Mastering Resolved Signals in VHDL: A Comprehensive Guide for Digital Design</title>
      <link>https://www.hdlfactory.com/post/2025/07/14/mastering-resolved-signals-in-vhdl-a-comprehensive-guide-for-digital-design/</link>
      <pubDate>Mon, 14 Jul 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/07/14/mastering-resolved-signals-in-vhdl-a-comprehensive-guide-for-digital-design/</guid>
      <description>I asked Gemini to teach me about the VHDL resolved signals. What you read below is the result.
 Mastering Resolved Signals in VHDL: A Comprehensive Guide for Digital Design 1. Introduction to Signals in VHDL The Fundamental Role of Signals in Hardware Description In VHDL, signals serve as the foundational elements for representing physical wires and interconnections within a digital circuit. They are paramount in describing hardware behavior because, unlike variables, signals inherently possess a time dimension.</description>
    </item>
    
    <item>
      <title>How to shoot yourself in the foot with inout signals</title>
      <link>https://www.hdlfactory.com/post/2025/07/07/how-to-shoot-yourself-in-the-foot-with-inout-signals/</link>
      <pubDate>Mon, 07 Jul 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/07/07/how-to-shoot-yourself-in-the-foot-with-inout-signals/</guid>
      <description>How to shoot yourself in the foot with inout signals They say that no good deed goes unpunished. Here’s an example of a footgun in VHDL which stems from in my view an eminently reasonable desire to keep the entity interface definitions compact.
When defining entities in VHDL, I try to keep the entity definition compact and keep the rate of mistakes low by grouping individual signals into records, so that they could be manipulated as a unit.</description>
    </item>
    
    <item>
      <title>VHDL IEEE Libraries and Numeric Type Conversion: A Definitive Reference</title>
      <link>https://www.hdlfactory.com/post/2025/06/29/vhdl-ieee-libraries-and-numeric-type-conversion-a-definitive-reference/</link>
      <pubDate>Sun, 29 Jun 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/06/29/vhdl-ieee-libraries-and-numeric-type-conversion-a-definitive-reference/</guid>
      <description>I asked Gemini to teach me the VHDL type conversions. What you read below is the result. An annoying generated podcast will be available for a while.
 VHDL IEEE Libraries and Numeric Type Conversions: A Definitive Reference Introduction The VHSIC Hardware Description Language (VHDL) is a formal, strongly-typed language engineered for use in all phases of the creation of electronic systems, including development, verification, synthesis, and testing.1 Its dual nature, being both human-readable and machine-readable, underpins its role in communicating, maintaining, and procuring hardware designs.</description>
    </item>
    
    <item>
      <title>Packaging AMD Xilinx Vivado ML Standard edition 2025.1 in a Docker container</title>
      <link>https://www.hdlfactory.com/post/2025/06/19/packaging-amd-xilinx-vivado-ml-standard-edition-2025.1-in-a-docker-container/</link>
      <pubDate>Thu, 19 Jun 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/06/19/packaging-amd-xilinx-vivado-ml-standard-edition-2025.1-in-a-docker-container/</guid>
      <description>I updated the repository https://github.com/filmil/vivado-docker/ with the changes required to package Vivado 2025.1. As of this writing, version 2025.1 is the last published version. I hope that the updated version will remove some of the bugs I discovered in the previous version I dockerized, which was 2023.2.
I use the container built from this repository as the basis for my vivado tooling for bazel. While this was the primary reason for making this dockerization recipe, the result is also usable as a stand-alone and ephemeral installation of Vivado.</description>
    </item>
    
    <item>
      <title>`rules_nixpkgs` use</title>
      <link>https://www.hdlfactory.com/post/2025/04/11/rules_nixpkgs-use/</link>
      <pubDate>Fri, 11 Apr 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/04/11/rules_nixpkgs-use/</guid>
      <description>rules_nixpkgs use This is a run-down of tips and tricks for the use of rules_nixpkgs, a rule set for bringing in nix packages for use in bazel.
I got involved with the use of rules_nixpkgs as a result of my work on hermetic, ephemeral and reproducible builds. My additions to the process are in the repository bazel_local_nix, which allows an ephemeral nix installation, only in service of the current bazel compilation.</description>
    </item>
    
    <item>
      <title>Bazel rules for &#34;build-in-docker&#34; (or &#34;bid&#34;)</title>
      <link>https://www.hdlfactory.com/post/2025/02/11/bazel-rules-for-build-in-docker-or-bid/</link>
      <pubDate>Tue, 11 Feb 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/02/11/bazel-rules-for-build-in-docker-or-bid/</guid>
      <description>Cross-posted from the original at https://github.com/filmil/bazel-rules-bid
What is &amp;ldquo;build-in-docker&amp;rdquo; (bid)? Bid allows you to create a build rule that runs a single bazel build action inside a Docker container.
What is bid not?   Bid is different from https://github.com/bazelbuild/rules_docker. Those are Bazel rules for building containers.
  Bid is also different from running bazel from a container described at https://bazel.build/install/docker-container. That is a way to run the entire bazel build inside a docker container.</description>
    </item>
    
    <item>
      <title>Typeset your own ebooks easily with `bazel-ebook`</title>
      <link>https://www.hdlfactory.com/post/2025/02/04/typeset-your-own-ebooks-easily-with-bazel-ebook/</link>
      <pubDate>Tue, 04 Feb 2025 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2025/02/04/typeset-your-own-ebooks-easily-with-bazel-ebook/</guid>
      <description>Other formats:
 Original content is at: https://github.com/filmil/bazel-ebook The rendered HTML edition at: https://hdlfactory.com/bazel_ebook_html/  Introduction  This repository is a set of bazel build rules that allow you to write a moderately complex book in the Markdown text format, and produce EPUB and Kindle&amp;rsquo;s MOBI formats from them. You can also produce a PDF format book, which allows you to preview the results slightly more convenient than by reading the resulting books.</description>
    </item>
    
    <item>
      <title>Using `glbl.v` module in a Verilog simulation in Vivado</title>
      <link>https://www.hdlfactory.com/note/2024/11/16/using-glbl.v-module-in-a-verilog-simulation-in-vivado/</link>
      <pubDate>Sat, 16 Nov 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/11/16/using-glbl.v-module-in-a-verilog-simulation-in-vivado/</guid>
      <description>A quick note about correct use of glbl.v in a Verilog simulation in Vivado. This note is way less confusing than any notes you may find elsewhere on the Internet.
glbl.v is a small collection of “global” signals that are being referred to in Vivado’s simulation sources for primitive elements in AMD (fka Xilinx) devices, such as OSERDES2 and others. This file gets included automatically in simulation setups if you use the Vivado GUI.</description>
    </item>
    
    <item>
      <title>Robust, well-tested Value Change Dump (VCD) Parser</title>
      <link>https://www.hdlfactory.com/post/2024/10/26/robust-well-tested-value-change-dump-vcd-parser/</link>
      <pubDate>Sat, 26 Oct 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/10/26/robust-well-tested-value-change-dump-vcd-parser/</guid>
      <description>From: https://github.com/filmil/go-vcd-parser
Value Change Dump (VCD) File parser 
This is a parser for the Value Change Dump files, a.k.a VCD file format. The file format is defined in the IEEE Standard 1800-2003. Specifically, the format supported at the moment is the 4-value format. Some pragmatic extensions are supported, such as those produced by the nvc VHDL simulator.
The correct behavior of the parser is guarded by a suite of tests.</description>
    </item>
    
    <item>
      <title>GNOME tips and tricks</title>
      <link>https://www.hdlfactory.com/note/2024/10/22/gnome-tips-and-tricks/</link>
      <pubDate>Tue, 22 Oct 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/10/22/gnome-tips-and-tricks/</guid>
      <description>Reusing the general approach from this post gives a way for setting Shift_L+Shift_R as layout change:
$ gsettings set org.gnome.desktop.wm.keybindings switch-input-source &amp;quot;[&#39;&amp;lt;Shift&amp;gt;Shift_L&#39;]&amp;quot; $ gsettings set org.gnome.desktop.wm.keybindings switch-input-source-backward &amp;quot;[&#39;&amp;lt;Shift&amp;gt;Shift_R&#39;]&amp;quot;  This can not be done from the GNOME settings UI. It also works only accidentally, since it is not possible to be very intentional about left and right Shift modifier in the shortcut key definitions. Whew.
  </description>
    </item>
    
    <item>
      <title>How to use $readmemh correctly</title>
      <link>https://www.hdlfactory.com/note/2024/10/07/how-to-use-readmemh-correctly/</link>
      <pubDate>Mon, 07 Oct 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/10/07/how-to-use-readmemh-correctly/</guid>
      <description>What? $readmemh is a Verilog directive that allows you to initialize an array.
It works differently in simulation compared to synthesis. In simulation, this directive behaves as a &amp;ldquo;read file into array&amp;rdquo;. In synthesis, this directive behaves as a repository of initial values for, say, block RAM.
While the purpose of the directive is documented every which way, the correct usage of the directive is woefully under-explained.
How to use it correctly If you have a file in a directory say:</description>
    </item>
    
    <item>
      <title>From zero to RISC-V in hardware, in 6 minutes</title>
      <link>https://www.hdlfactory.com/post/2024/10/05/from-zero-to-risc-v-in-hardware-in-6-minutes/</link>
      <pubDate>Sat, 05 Oct 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/10/05/from-zero-to-risc-v-in-hardware-in-6-minutes/</guid>
      <description>From zero to RISC-V in hardware, in 6 minutes  Program your FPGA with a one-liner command. It&amp;rsquo;s a kind of magic.
 This is a project in sustainable FPGA development that I have been working on. It ties together several smaller projects that I developed in a perpetual quest for hermetic, ephemeral, and reproducible builds. As far as I know, you can not find any setup like this anywhere else.</description>
    </item>
    
    <item>
      <title>nix requires `ranlib`</title>
      <link>https://www.hdlfactory.com/note/2024/09/14/nix-requires-ranlib/</link>
      <pubDate>Sat, 14 Sep 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/09/14/nix-requires-ranlib/</guid>
      <description>Be forewarned: HER builds with nix require a functional ranlib This is something seldom known, and a very sharp corner to cut yourself on. But you really want to know if you are using nix.
I lost an entire day trying to figure out mysterious “symbol not found” errors while trying to link a hermetic instance of the nvc VHDL compiler under bazel with rules_foreign_cc, in a HER build, when using link-time optimizations (“LTO”), which is the norm these days.</description>
    </item>
    
    <item>
      <title>`bazel` rules for GHDL</title>
      <link>https://www.hdlfactory.com/post/2024/09/03/bazel-rules-for-ghdl/</link>
      <pubDate>Tue, 03 Sep 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/09/03/bazel-rules-for-ghdl/</guid>
      <description>bazel rules for GHDL I present to you https://github.com/filmil/bazel_rules_ghdl: a set of bazel rules for converting VHDL into Verilog.
This for example allows running VHDL code in a Verilator simulation. Commercial tools usually do not care what HDL the modules are written in. But usually commercial tools are the final mile in open source HDL development.
Before you get there, you want the ability to run reasonably detailed simulations.
What? This repository contains a bazel rule set for running ghdl, the VHDL simulator and synthesizer, specifically to convert VHDL designs into Verilog.</description>
    </item>
    
    <item>
      <title>`bazel` rules for a riscv64 bare metal rust compiler</title>
      <link>https://www.hdlfactory.com/note/2024/08/31/bazel-rules-for-a-riscv64-bare-metal-rust-compiler/</link>
      <pubDate>Sat, 31 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/08/31/bazel-rules-for-a-riscv64-bare-metal-rust-compiler/</guid>
      <description>bazel rules for a riscv64 bare metal rust compiler  This article assumes that you have bazel installed via the bazelisk method.
 This is the latest example in my repository at: https://github.com/filmil/bazel-experiments
The subdirectory https://github.com/filmil/bazel-experiments/tree/main/riscv64-rust-baremetal shows how to build a bare-metal binary for 64-bit RISC-V, using bazel and a hermetic Rust compiler.
It leans onto the set of bazel bare metal rules for 64-bit RISC-V, since the Rust compiler uses GNU ld for its linker.</description>
    </item>
    
    <item>
      <title>`bazel` installation via the `bazelisk` method</title>
      <link>https://www.hdlfactory.com/note/2024/08/24/bazel-installation-via-the-bazelisk-method/</link>
      <pubDate>Sat, 24 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/08/24/bazel-installation-via-the-bazelisk-method/</guid>
      <description>bazel installation via the bazelisk method Here is how I install bazel. I use this installation method on all of my machines. I do not think it is practical to go about this any other way. It is implied in all of my writings about bazel.
Why? Sadly, bazel versions are wildly incompatible between major version releases. This means that as you encounter projects using newer and newer bazel versions, you may encounter random compatibility issues.</description>
    </item>
    
    <item>
      <title>`bazel` rules for a riscv64 bare metal GCC compiler</title>
      <link>https://www.hdlfactory.com/note/2024/08/17/bazel-rules-for-a-riscv64-bare-metal-gcc-compiler/</link>
      <pubDate>Sat, 17 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/08/17/bazel-rules-for-a-riscv64-bare-metal-gcc-compiler/</guid>
      <description>bazel rules for a riscv64 bare metal GCC compiler The repository https://github.com/filmil/bazel_rules_gcc_riscv64_baremetal contains bazel rules that can be used for a hermetic bare metal GCC cross-compiler for a 64-bit RISC-V machine, running in M-mode.
It is based on the toolchain for the muntjac processor. Based on the lowRISC toolchains repo at: https://github.com/lowRISC/lowrisc-toolchains, and some custom patches.
  </description>
    </item>
    
    <item>
      <title>`lazygit` tips and tricks</title>
      <link>https://www.hdlfactory.com/note/2024/08/12/lazygit-tips-and-tricks/</link>
      <pubDate>Mon, 12 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/08/12/lazygit-tips-and-tricks/</guid>
      <description>lazygit tips and tricks These are some tips and tricks for lazygit that I keep forgetting how to do.
Split a commit into multiple commits Based on the discussion here.
 Open lazygit 4 to move to the commits panel Enter key to select a commit to split Use regular commands to stage and unstage parts you need. Ctrl-P n to select &amp;ldquo;move to new commit&amp;rdquo;. Write the commit message. Ctrl-O does not seem to work, so I usually put an arbitrary but memorable blurb, and reword the commit later.</description>
    </item>
    
    <item>
      <title>Remote programming of an AMD (fka Xilinx) Artix-7 device</title>
      <link>https://www.hdlfactory.com/post/2024/07/08/remote-programming-of-an-amd-fka-xilinx-artix-7-device/</link>
      <pubDate>Mon, 08 Jul 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/07/08/remote-programming-of-an-amd-fka-xilinx-artix-7-device/</guid>
      <description>Summary Here is how you can set up a hardware server (hw_server) in AMD Vivado 2023.2.
Once you do this, that you can move your workbench to a virtual machine in your cloud of choice - mine is GCP - but program a device which is attached to a machine that&amp;rsquo;s close to you.
The FPGA device in question is an AMD Artix-7 A200T. I suspect any other device supported by Vivado will work too.</description>
    </item>
    
    <item>
      <title>PSA: Google Nest Router can serve as an Access Point</title>
      <link>https://www.hdlfactory.com/note/2024/05/25/psa-google-nest-router-can-serve-as-an-access-point/</link>
      <pubDate>Sat, 25 May 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/05/25/psa-google-nest-router-can-serve-as-an-access-point/</guid>
      <description>Google Nest Router (2nd Generation) can serve as an access point I accidentally bought the Google Nest 2nd Generation Router when I needed an Access Point.
It turns out that the Router can act as an Access Point and join a mesh network that already has an active Router. Just select &amp;ldquo;Access Point&amp;rdquo; when setting it up instead of &amp;ldquo;Router&amp;rdquo;.
This is very useful in multiple ways:
 If you accidentally buy the wrong device; If you don&amp;rsquo;t want the microphone that&amp;rsquo;s built into the Access Point.</description>
    </item>
    
    <item>
      <title>Hermetic, ephemeral, reproducible builds (&#39;her&#39;)</title>
      <link>https://www.hdlfactory.com/note/2024/05/01/hermetic-ephemeral-reproducible-builds-her/</link>
      <pubDate>Wed, 01 May 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/05/01/hermetic-ephemeral-reproducible-builds-her/</guid>
      <description>Summary This short note defines the notions of hermetic, ephemeral and reproducible software build, as used in my writing.
I call this &amp;ldquo;her&amp;rdquo; for short.
Hermetic A build is said to be hermetic, if each build step only has access to the set of input artifacts that are minimally required for the build to succeed.
Hermeticity is useful to ensure build correctness &amp;ndash; as it allows us to confirm that each build dependency step is well captured, and that none are omitted.</description>
    </item>
    
    <item>
      <title>Why do I bother with `bazel`?</title>
      <link>https://www.hdlfactory.com/post/2024/04/27/why-do-i-bother-with-bazel/</link>
      <pubDate>Sat, 27 Apr 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/04/27/why-do-i-bother-with-bazel/</guid>
      <description>Summary I bother with bazel.
Here is why.
Background Bazel is a build system. Originally created at Google for internal purposes, then eventually open sourced. Since then, it has not been universally accepted. You can find discussions where bazel is being put down in favor of other build systems.
Yet, I have been using bazel in a lot of my recent projects, and have been quite pleased with the results. I intend to explain here why this works for me.</description>
    </item>
    
    <item>
      <title>Nix&#43;Bazel = ❤️</title>
      <link>https://www.hdlfactory.com/post/2024/04/20/nix-bazel-%EF%B8%8F/</link>
      <pubDate>Sat, 20 Apr 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/04/20/nix-bazel-%EF%B8%8F/</guid>
      <description>If you are in a hurry, fast forward to https://github.com/filmil/bazel_local_nix
Summary You, too, can have a fully hermetic, reproducible, and ephemeral bazel build.
Intro While looking for non-invasive and reproducible ways to create my dev environment, I considered bazel. I wrote up some of the results of this search.
I like bazel because not only will it build my project reproducibly, but will also set up the development environment for doing so beforehand.</description>
    </item>
    
    <item>
      <title>`docker` tips and tricks</title>
      <link>https://www.hdlfactory.com/post/2024/02/15/docker-tips-and-tricks/</link>
      <pubDate>Thu, 15 Feb 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/02/15/docker-tips-and-tricks/</guid>
      <description>Docker tips and tricks Save an image to an archive docker save imagename | gzip &amp;gt; myimage.tar.gz  Load image to an archive docker load &amp;lt; myimage.tar.gz    </description>
    </item>
    
    <item>
      <title>bazel does not like FIFOs</title>
      <link>https://www.hdlfactory.com/post/2024/02/05/bazel-does-not-like-fifos/</link>
      <pubDate>Mon, 05 Feb 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/02/05/bazel-does-not-like-fifos/</guid>
      <description>Bazel does not like FIFOs Perhaps obvious in retrospect, but it is not possible for a bazel build artifact to generate a named pipe in the filesystem.
The after-step checks will object if an output directory contains at least one.
I am not sure if this is accidental or not, but it kind of makes sense, since FIFOs are not hermetic, just as network connections are not hermetic.
You can see the error message that one of my build rules hit when attempting to create a FIFO.</description>
    </item>
    
    <item>
      <title>Unix domain sockets in go</title>
      <link>https://www.hdlfactory.com/note/2024/01/06/unix-domain-sockets-in-go/</link>
      <pubDate>Sat, 06 Jan 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2024/01/06/unix-domain-sockets-in-go/</guid>
      <description>After a lengthy search I found the below article that explains the use of Unix domain sockets in go:
 https://johnrefior.com/gobits/read/go-introduction-to-unix-socket-communication    </description>
    </item>
    
    <item>
      <title>Running docker containers in Synology NAS</title>
      <link>https://www.hdlfactory.com/post/2024/01/01/running-docker-containers-in-synology-nas/</link>
      <pubDate>Mon, 01 Jan 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2024/01/01/running-docker-containers-in-synology-nas/</guid>
      <description>If this advice helped you, let me know.
 How to run docker containers under Synology NAS, easily and with custom settings Prompted by a recent need to run a local Jupyter instance using the Jupyter Docker Stacks.
The easiest way to run docker containers under Synology NAS is to use the Container Manager, which is available through Synology&amp;rsquo;s Package Center right from the user interface.
The Container Manager allows you to run custom containers and set some, but not all, options.</description>
    </item>
    
    <item>
      <title>TIM-011 video playlist</title>
      <link>https://www.hdlfactory.com/post/2023/12/25/tim-011-video-playlist/</link>
      <pubDate>Mon, 25 Dec 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/12/25/tim-011-video-playlist/</guid>
      <description>TIM-011 video playlist  TIM-011 was an 8-bit teaching computer that was ostensibly developed by IMP in what is now Serbia.
 Here is a public collection of videos related to the TIM-011 computer. Most of the videos, and especially the more impressive ones, are by other people. Please see individual videos for authorship information.
 </description>
    </item>
    
    <item>
      <title>TIM-011 gets a unit test library</title>
      <link>https://www.hdlfactory.com/post/2023/12/24/tim-011-gets-a-unit-test-library/</link>
      <pubDate>Sun, 24 Dec 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/12/24/tim-011-gets-a-unit-test-library/</guid>
      <description>TIM-011 was an 8-bit teaching computer that was ostensibly developed by IMP in what is now Serbia.
 It is hard to develop for any machine without a way to test quickly whether your work results in something usable. Since it takes quite a while to spin up a TIM-011 emulator and run things on it, it was not going to be practical to wait for all the slow machinery to get spun up.</description>
    </item>
    
    <item>
      <title>bazoekt: easy code indexing and search for your Bazel projects</title>
      <link>https://www.hdlfactory.com/post/2023/12/17/bazoekt-easy-code-indexing-and-search-for-your-bazel-projects/</link>
      <pubDate>Sun, 17 Dec 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/12/17/bazoekt-easy-code-indexing-and-search-for-your-bazel-projects/</guid>
      <description>https://github.com/filmil/bazoekt
 Update 2026-04-17: Bazoekt has been modernized and revived. Sourcegraph has taken over maintenance of bazoekt, but what they actually did was disable the old repo and dismantle the bazoekt infrastructure, so it couldn&amp;rsquo;t be compiled. I took over the old version of bazoekt, spruced it up so that it builds again, and put it up at https://github.com/filmil/zoekt.
 Since I can’t remember anything these days, I often find myself sifting through my code looking for specific keywords.</description>
    </item>
    
    <item>
      <title>bazel: excavating an unknown file from a `foreign_cc` rule</title>
      <link>https://www.hdlfactory.com/post/2023/12/14/bazel-excavating-an-unknown-file-from-a-foreign_cc-rule/</link>
      <pubDate>Thu, 14 Dec 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/12/14/bazel-excavating-an-unknown-file-from-a-foreign_cc-rule/</guid>
      <description>Excavating an unknown file from a foreign_cc rule I discovered this trick recently, while trying (and mostly failing) to build a library.
I discovered that it is possible to excavate an arbitrary file from the resulting directory by using the gen_dir file group, then copying out the needed file using genrule.
Entire BUILD.bazel:
load(&amp;quot;@rules_foreign_cc//foreign_cc:defs.bzl&amp;quot;, &amp;quot;make&amp;quot;) filegroup( name = &amp;quot;all_files&amp;quot;, srcs = glob([&amp;quot;**&amp;quot;]), ) make( name = &amp;quot;lib&amp;quot;, targets = [ &amp;quot; -C $BUILD_TMPDIR&amp;quot; + &amp;quot; BIN_DIR=$$INSTALLDIR$$/lib&amp;quot; + &amp;quot; ROOT=$BUILD_TMPDIR&amp;quot; + &amp;quot; EXT_BUILD_ROOT=$EXT_BUILD_ROOT&amp;quot; + &amp;quot; CC=$EXT_BUILD_ROOT/$SDCC&amp;quot; + &amp;quot; AS=$EXT_BUILD_ROOT/$SDAS&amp;quot; + &amp;quot; AR=$EXT_BUILD_ROOT/$SDAR&amp;quot; + &amp;quot; CPP=$EXT_BUILD_ROOT/$SDCPP&amp;quot; + &amp;quot; LD=$EXT_BUILD_ROOT/$SDLD&amp;quot; + &amp;quot; ISET=-mz180&amp;quot; + &amp;quot; all&amp;quot;, ], env = { &amp;quot;CFLAGS&amp;quot;: &amp;quot;&amp;quot;, &amp;quot;CXXFLAGS&amp;quot;: &amp;quot;&amp;quot;, &amp;quot;AR_FLAGS&amp;quot;: &amp;quot;&amp;quot;, &amp;quot;ARFLAGS&amp;quot;: &amp;quot;&amp;quot;, &amp;quot;LDFLAGS&amp;quot;: &amp;quot;&amp;quot;, &amp;quot;SDCC&amp;quot;: &amp;quot;$(location @sdcc-linux//:sdcc)&amp;quot;, &amp;quot;SDAS&amp;quot;: &amp;quot;$(location @sdcc-linux//:sdas)&amp;quot;, &amp;quot;SDAR&amp;quot;: &amp;quot;$(location @sdcc-linux//:sdar)&amp;quot;, &amp;quot;SDCPP&amp;quot;: &amp;quot;$(location @sdcc-linux//:sdcpp)&amp;quot;, &amp;quot;SDLD&amp;quot;: &amp;quot;$(location @sdcc-linux//:sdld)&amp;quot;, }, install_prefix = &amp;quot;_install&amp;quot;, lib_source = &amp;quot;:all_files&amp;quot;, out_static_libs = [ &amp;quot;libcpm3-z80.</description>
    </item>
    
    <item>
      <title>TIM-011 gets a C runtime library</title>
      <link>https://www.hdlfactory.com/post/2023/12/13/tim-011-gets-a-c-runtime-library/</link>
      <pubDate>Wed, 13 Dec 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/12/13/tim-011-gets-a-c-runtime-library/</guid>
      <description>TIM-011 gets a C runtime library  TIM-011 was an 8-bit teaching computer that was ostensibly developed by IMP in what is now Serbia.
 Now that https://github.com/filmil/tim011-tools/issues/3 has been fixed, the TIM-011 tools compile and run with a real C runtime library, thanks to the libcpm-z80 library.
It wasn&amp;rsquo;t easy to get it to compile with bazel, but after plenty of trial and error I managed to pinpoint the correct incantation.</description>
    </item>
    
    <item>
      <title>TIM-011 computer - how we did things back then</title>
      <link>https://www.hdlfactory.com/note/2023/12/03/tim-011-computer-how-we-did-things-back-then/</link>
      <pubDate>Sun, 03 Dec 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2023/12/03/tim-011-computer-how-we-did-things-back-then/</guid>
      <description>I was a bit hard pressed to find all the proper work attribution. Please let me know if you have data to contribute.
 TIM-011 TIM-011 was an 8-bit teaching computer that was ostensibly developed by IMP in what is now Serbia.
It was one of the machines that kick-started my career as a software engineer. For better or worse.
There are precious few resource links for TIM-011, a machine that I personally hold in high regard because of its sentimental value to me.</description>
    </item>
    
    <item>
      <title>Packaging AMD Xilinx Vivado ML Standard edition in a Docker container</title>
      <link>https://www.hdlfactory.com/post/2023/11/20/packaging-amd-xilinx-vivado-ml-standard-edition-in-a-docker-container/</link>
      <pubDate>Mon, 20 Nov 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/11/20/packaging-amd-xilinx-vivado-ml-standard-edition-in-a-docker-container/</guid>
      <description>A while back I wanted to make a hermetic environment for repeatably running Docker tooling.
The results are here: https://github.com/filmil/vivado-docker/
At this time, it&amp;rsquo;s only able to run the GUI version of the tool. I intend to make it run specific tools when they are needed.
  </description>
    </item>
    
    <item>
      <title>Neovim tips and tricks</title>
      <link>https://www.hdlfactory.com/post/2023/09/18/neovim-tips-and-tricks/</link>
      <pubDate>Mon, 18 Sep 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/09/18/neovim-tips-and-tricks/</guid>
      <description>From VimScript into Lua This is my cheat sheet for migrating VimScript into Lua. Things I often forget. There are places to learn about Lua use in Neovim . But, for some reason, I could not find side-by-side examples of VimScript vs Lua for quick migration. So I decided to start my own.
   VimScript Lua     :nmap abc :something vim.keymap.add({&#39;n&#39;}, &#39;abc&#39;, &#39;:something), noremap will be with more in the first {}   let g:session_autosave = &#39;yes&#39; vim.</description>
    </item>
    
    <item>
      <title>`git` tips and tricks</title>
      <link>https://www.hdlfactory.com/post/2023/08/05/git-tips-and-tricks/</link>
      <pubDate>Sat, 05 Aug 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/08/05/git-tips-and-tricks/</guid>
      <description>Often needed little bits of git knowledge that I tend to forget.
Check out the contents of a GitHub PR From: https://devopscube.com/checkout-git-pull-request/
git fetch origin pull/15/head:test-branch  This will fetch the PR number 15 from GitHub, and have it available in the local branch test-branch.
  </description>
    </item>
    
    <item>
      <title>`bazel` tips and tricks</title>
      <link>https://www.hdlfactory.com/post/2023/07/30/bazel-tips-and-tricks/</link>
      <pubDate>Sun, 30 Jul 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/07/30/bazel-tips-and-tricks/</guid>
      <description>Often needed little bits of bazel knowledge that I tend to forget.
Module extensions Reminder about module extensions.
# Also instead of `http.bzl`, `git.bzl` etc. http_file = use_repo_rule(&amp;quot;@bazel_tools//tools/build_defs/repo:http.bzl&amp;quot;, &amp;quot;http_file&amp;quot;) http_file( name = &amp;quot;data_file&amp;quot;, url = &amp;quot;http://example.com/file&amp;quot;, sha256 = &amp;quot;e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855&amp;quot;, )  Print errors inline By default bazel prints the path to error logs. In development it is often more useful to see the error printed right away.
bazel test --test_output=errors //.</description>
    </item>
    
    <item>
      <title>Build a `python` web app in `bazel`</title>
      <link>https://www.hdlfactory.com/post/2023/07/25/build-a-python-web-app-in-bazel/</link>
      <pubDate>Tue, 25 Jul 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/07/25/build-a-python-web-app-in-bazel/</guid>
      <description>Here is an example python Flask app built with Bazel. See README.md for instructions.
Running the app will start a local dev server for Flask and you should be able to direct your browser at it and see the result. Based on various bits and pieces from the internet on how to do this correctly.
It uses a hermetic python interpreter, which a great improvement for reproducibility over using the local python interpreter.</description>
    </item>
    
    <item>
      <title>Tesla ownership experiences so far</title>
      <link>https://www.hdlfactory.com/note/2023/06/30/tesla-ownership-experiences-so-far/</link>
      <pubDate>Fri, 30 Jun 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2023/06/30/tesla-ownership-experiences-so-far/</guid>
      <description>We recently became Tesla owners, as our old car unexpectedly gave out. We were expecting to get at least 1 more year out of it. But it was not meant to be.
Now that we&amp;rsquo;re obnoxious Tesla owners, it is only fair that I bother you with some Electric vehicle ownership experience writeup, for what we figured out so far.
  </description>
    </item>
    
    <item>
      <title>Including arbitrary files into `cc_library` rule in `bazel`</title>
      <link>https://www.hdlfactory.com/note/2023/06/23/including-arbitrary-files-into-cc_library-rule-in-bazel/</link>
      <pubDate>Fri, 23 Jun 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/note/2023/06/23/including-arbitrary-files-into-cc_library-rule-in-bazel/</guid>
      <description>Update 2023-08-17: This is now a feature in bazel, see https://github.com/bazelbuild/bazel/issues/18766 for details. It is available starting bazel version 6.3.0. Use additional_compiler_input parameter to cc_library and other C++ rules to provide arbitrary files.
 Adapted from the bazel-discuss mailing list.
 I have a cc_library.
I want to set &amp;ldquo;-fsanitize-ignorelist&amp;rdquo; to point to a file in my repo.
E.g., I have:
foo.cc BUILD.bazel ignorelist.txt  and in BUILD.bazel:
cc_library( name = &amp;quot;foo&amp;quot;, copts = [&amp;quot;-fsanitize-ignorelist=&amp;quot; &amp;lt;TODO what goes here?</description>
    </item>
    
    <item>
      <title>How to use the `make` rule from `rules_foreign_cc` repository for `bazel`</title>
      <link>https://www.hdlfactory.com/post/2023/06/13/how-to-use-the-make-rule-from-rules_foreign_cc-repository-for-bazel/</link>
      <pubDate>Tue, 13 Jun 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hdlfactory.com/post/2023/06/13/how-to-use-the-make-rule-from-rules_foreign_cc-repository-for-bazel/</guid>
      <description>Summary The bazel build system has rules available to build C or C++ code from external repositories that use other more &amp;ldquo;conventional&amp;rdquo; build tools. By this I mean the usual suspects: GNU autotools, GNU make and cmake.
This rules repository is called rules_foreign_cc. While it is somewhat documented, and even has examples, both leave a lot to be desired.
I think it would be really helpful to have at least some sort of a guide for how exactly they work, so that we can use them more effectively.</description>
    </item>
    
  </channel>
</rss>
