This discussion convinced me to give another go at trying to make an iterator interface in Zig.
4 Likes
Finally got syscall filtering work on aarch64 macos, all it took was to make process virtualize itself 
./.zig-cache/o/cee8bd191da6115485889a726cbaef10/sorvi-frontend ./.zig-cache/o/ba714225f87b8808692cac3da4df3c12/minimal.sorvi
info(sorvi_headless): ./.zig-cache/o/ba714225f87b8808692cac3da4df3c12/minimal.sorvi: loaded at address 1097b0000
info(sorvi_headless): installing Hypervisor.framework sandbox
info(sorvi_headless): installing VBAR_EL1 trampoline at 104c3c000
info(sorvi_headless): setting SP_EL0 to 109fe0000
info(sorvi_headless): setting tpidr_el0 to 1004
info(sorvi_headless): setting tpidrro_el0 to 20992f160
info(sorvi_headless): jumping to entry: 104a1bc58
info(sorvi_headless): running on aarch64-macos
info(minimal_example): Hello world!
info(minimal_example): Now direct syscall:
error(sorvi_headless): core tried to make a syscall, aborting ...
./.zig-cache/o/cee8bd191da6115485889a726cbaef10/sorvi-frontend --trust ./.zig-cache/o/ba714225f87b8808692cac3da4df3c12/minimal.sorvi
info(sorvi_headless): ./.zig-cache/o/ba714225f87b8808692cac3da4df3c12/minimal.sorvi: loaded at address 104f90000
info(sorvi_headless): running on aarch64-macos
info(minimal_example): Hello world!
info(minimal_example): Now direct syscall:
Hello world! (syscall)
8 Likes
I’m currently working on Converged (GitHub - solenopsys/converged: Converged - Smart Workshop Core · GitHub) - a system that brings all workshop equipment into a single environment: CNC machines, 3D printers, and other industrial hardware, while also integrating LLMs, audio gateways, telephony, and process automation.
All low-level infrastructure and system components are written in Zig. The business logic inside individual systems is written in TypeScript / QuickJS or runs through Cruller (GitHub - solenopsys/cruller: fork of Bun · GitHub), my fork of Bun.
So Zig handles the fast, compact systems layer, while TS/JS is used for application logic that can be changed and extended quickly.
3 Likes
I’ve being working on a embedded kv engine, very interesting
4 Likes
I released my self-made audio engine and editor a few days ago. Available now in open beta!
More info here: https://www.byprod.io/
Zig bindings available (naturally 
): byProdResources/bindings/zig/byprod.zig at main · MadrigalGames/byProdResources · GitHub
19 Likes
Check Links is a command-line utility (CLI) written in Zig for checking links on a web page.
Since the HTTP client does not implement timeouts, we had to implement our own connection and HTTP client with support for TSL and timeouts.
Typical Use Cases
1. Checking for broken links on your site after a redesign or migration
After changing the design, URL structure, or moving to a new domain, you should make sure that no links point to old (removed) sections or files.
check_links --fail https://example.com/page/
The utility shows only links that lead to non-existent pages (404, 410) or server errors (500).
2. SEO audit: finding links to external resources that stopped working
Broken external links harm behavioral factors and search-engine trust in your site. Regularly checking external links is a mandatory part of SEO maintenance.
check_links --export broken-links.csv https://example.com/
The CSV file can be opened in Excel/Google Sheets and handed to a content manager for fixing.
3. Checking links in an article or landing page before publication
Before publishing content with many external sources, it helps to verify that all links are working and do not lead to 404.
check_links https://blog.example.com/draft-article/
Green 200 codes mean everything is fine, yellow 3xx means redirects (worth updating the links to current ones), red 4xx/5xx are broken links.
4. Monitoring links in documentation or a knowledge base
For sites with extensive documentation (wikis, knowledge bases, manuals), it is useful to set up a regular link check so that the documentation stays up to date.
# Weekly check via cron
0 6 * * 1 /usr/local/bin/check_links --fail --export /var/log/links-check/docs-errors.csv https://docs.company.ru/
5. Checking links on a product page in an online store
Product cards often contain links to related products, categories, and reviews. If such links lead nowhere, it is a direct loss of sales.
check_links --fail https://store.example.com/catalog/product-123/
6. Auditing a link profile before buying links
When doing SEO, before buying links from a donor site, it is worth checking whether it has broken pages that could reduce the effect of the purchase.
check_links --fail https://donor-site.example.com/
7. Finding images that fail to load
The utility collects not only links (<a href>) but also images (<img src>). This lets you find broken images on a page — a common cause of poor visual perception of a site.
check_links --fail https://example.com/gallery/
8. Checking redirects (redirect chains)
Although the utility does not follow redirect chains step by step, it shows the 3xx HTTP code for URLs that redirect. This helps to identify unnecessary intermediate redirects that slow down page loading.
check_links https://example.com/
Pay attention to the yellow rows — these are URLs returning 301, 302, etc.
9. Exporting a full link map of a page for further analysis
CSV export lets you pass results to BI systems, Google Sheets, or Excel for building reports and dashboards.
check_links --export full-links-report.csv https://example.com/
10. Quick client site check before a presentation
For agencies and freelancers: before showing a site to a client, run the home page and typical pages through the utility to avoid an awkward situation with broken links during a demo.
check_links --fail https://client-site.example.com/
1 Like
I’ve been working on this recently — a high-performance data container. Strictly speaking, it’s aimed at the Python ecosystem, but Zig provides the core underlying support.
2 Likes
Checking links for what?
I personally use hledger for accounting due to its rule files that let you program how your CSV files get converted into the ledger (and prevent duplicates). Might be worth a look for inspiration, if you aren’t already familiar with it 
Love the UI. Looks really slick.
1 Like
To check for broken links on the page.
The README.md file contains 10 typical use cases for the utility, based on frequent requests from our clients.
Bread-and-butter equalizer au-vst plugin. C++ mostly, zig is used for building the project. Using JUCE library. Still working on it.
What happened to Samatas DS from What’s everybody working on July Edition? I must port it to JUCE, it will take some months. Some progress since last time.
12 Likes
Zig bindings for JUCE when?
1 Like
Somewhat on topic. I’ve been hacking on @SuperAuguste’s zig bindings for LV2, as an exercise to learn zig and lv2. I’d be happy to get any feedback.
I got the sampler example working 
PS: I love zig. It makes me a better person.
6 Likes
A while back I tried using Doorstop, immediately hit some weird bugs and eventually concluded I disagreed with some of the design decisions. So, in my hubris, I decided to make my own version in Zig.
I mostly leverage the zig-yaml library (with some extensions, published on my fork) for parsing data, although it got complicated once I started dealing with custom attributes (the moment I thought maybe I should have done this in a dynamically-typed language!).
I had basic processing of Document definitions working a while ago, but over the past few days I updated the code to support Zig 0.16, added loading Items from YAML strings, as well as support for custom attributes and types.
Not publishing yet, as there’s essentially nothing by way of UI to speak of.
2 Likes
Currently working on an immediate mode gui library (actually it’s just a single 4k loc zig file).
It does the auto layout and sizing computations of widgets you declare and returns a single command buffer that tells the user what to draw and where (kinda like rxi microui).
I started working on it for my own personal project, now i plan to share the file once it’s solid.
Below is a demo screenshot of current progress:
13 Likes
I just started working on a multi call binary with a bunch of small userspace utils called hako. For now I aim to provide these commands:
watchfd: inspect file descriptors of a process in a refreshing view
dumpfd: inspect a snapshot of file descriptors of a given process
listen: tcp/unix sockets
pwait: wait for a proc to disappear
when: execute a command when a file/directory changes
ports: print ports and the processes that listen on them
Currently I only implemented two of them.
watchfd uses the Linux ptrace syscall to continously monitor file descriptor changes of a given process and unfortunately will require sudo on most distributions. More about how it works can be found here. Currently the output has no delay when refreshing which makes it not that usable unless you are a really quick reader.
dumpfd just reads the /proc/<pid>/fd of a given process and resolves the symlinks. Essentially the same output as watchfd but only of a single point in time.
Here is a screenshot of the dumpfd output:
Also on GitHub if that’s your cup of tea : )
3 Likes
I’ve been working on a small project in Zig: dlt-zcan , a DLT (Diagnostic Log and Trace) filter tool for large automotive log files.
DLT is a logging/tracing format commonly used in the automotive industry. The goal of this project is to efficiently filter large DLT logs by ECU ID, application/context ID, log level, or payload substring, while keeping memory usage low through streaming.
I also recently added pretty-printing for verbose DLT messages, including integers, floats, strings, raw data, booleans, and arrays.
For example:
ECU=ECU APID=LOG CTID=TES4 Level=INFO | [0, "Hello world"]
ECU=ECU APID=LOG CTID=TES4 Level=INFO | [1, "Hello world"]
ECU=ECU APID=LOG CTID=TES4 Level=INFO | [2, "Hello world"]
I benchmarked it on a 4.2 GB DLT log. On my i5-7200U, processing the file without filtering takes ~7.1 s, compared to ~4.4 s for cat to /dev/null .
The project is still a work in progress, but I’m pretty happy with how the parser and zero-copy-ish streaming design have turned out so far. Especially bit sized integers and zero cost bitcasts came in handy for this tiny hobby project.
1 Like
September Thread: