DEV Community: Black Tornado

You have been zigged (series) : Loading library at runtime

Black Tornado — Wed, 10 Jun 2026 01:40:46 +0000

It is possible to load a library at runtime without linking it at compile time statically nor dynamically. The POSIX functions that allow us to do this are dlopen(), dlsym(), dlerror() and dlclose() (these functions are found under dlfcn.h). The zig equivalent functions are found under std.DynLib. The purposes of why one might want to do this is to load plugins or to load optional features. So lets write a small "plugin" that adds two numbers.

Note: At the time of writing, latest stable version of zig is 0.16.0 and windows implementation for this functionality is not present in std lib. Because of this we are going with Linux.

// plugin__add.zig
export fn my_add(num1: i32, num2: i32) callconv(.c) i32 {
    return num1 + num2;
}

Lets build dynamic library using zig build-lib -dynamic -O ReleaseSafe plugin__add.zig. This will create libplugin__add.so. Now lets write main code.

// plugin__main.zig
const std = @import("std");

pub fn main(init: std.process.Init) !void {
    // setting up stdout writer
    var buffer: [1024]u8 = undefined;
    var file_writer = std.Io.File.Writer.init(.stdout(), init.io, &buffer);
    var stdout_writer = &file_writer.interface;

    var lib = try std.DynLib.open("./libplugin__add.so");
    defer lib.close();
    const AddFn = *const fn (num1: i32, num2: i32) callconv(.c) i32;
    const my_add = lib.inner.lookup(AddFn, "my_add").?;

    try stdout_writer.print("{}+{}={}\n", .{ 5, 6, my_add(5, 6) });
    try stdout_writer.flush();
}

Lets build our main code using zig build-exe -O ReleaseSafe plugin__main.zig. This will create plugin__main executable which will print 5+6=11.

Thanks for reading. To be continued.

You have been zigged (series) : Linking a library statically and dynamically

Black Tornado — Tue, 09 Jun 2026 11:14:31 +0000

Static linking

In this blog, we will explore how to link a zig library statically and dynamically.

First lets create a library that contains a function my_add that adds two numbers. Note that instead of pub keyword which we used in previous blog, we will be using export keyword to decorate the my_add function. This tells the zig compiler to expose the my_add function through C ABI.

// libraries__add.zig
export fn my_add(num1: i32, num2: i32) i32 {
    return num1 + num2;
}

Build the libraries__add.zig file as a static library using the command zig build-lib -O ReleaseSafe libraries__add.zig. This will output a liblibraries__add.a file on current folder if you are using linux or libraries__add.dll file if you are on windows.

To use this my_add function in our main code to add numbers, we will declare the my_add function's signature in main code using extern keyword. Then at compile time, we will tell the zig compiler to link the liblibraries__add.a/libraries__add.dll with our main output.

// libraries__main1.zig
const std = @import("std");

extern fn my_add(num1: i32, num2: i32) i32;

pub fn main(init: std.process.Init) !void {
    // setting up stdout writer
    var buffer: [1024]u8 = undefined;
    var file_writer = std.Io.File.Writer.init(.stdout(), init.io, &buffer);
    var stdout_writer = &file_writer.interface;

    try stdout_writer.print("{}+{}={}\n", .{ 5, 6, my_add(5, 6) });
    try stdout_writer.flush();
}

Let's build our main code and link liblibraries__add.a/libraries__add.dll with the output using zig build-exe libraries__main1.zig liblibraries__add.a or zig build-exe libraries__main1.zig libraries__add.dll.

The above command will produce a libraries__main1 which when executed will print 5+6=11.

Once libraries__main1 is created, we can delete the liblibraries__add.a/libraries__add.dll file and the libraries__main1 executable will still work. This is because the library was linked statically - the entire library was copied to the final executable. Advantage of doing static linking is creation of a final binary that has no runtime dependency. Disadvantage is duplication across binaries and increased file size. Hence dynamic linking.

Dynamic linking

To dynamically link liblibraries__add.a/libraries__add.dll with libraries__main1, we pass -dynamic flag to the zig compiler when building libraries__add.zig. The build command will look like zig build-lib -O ReleaseSafe -dynamic libraries__add.zig. This will produce a liblibraries__add.so in linux and libraries__add.dll in windows. Even though the file extension is same as earlier in windows, the DLL will be position independent code. The build command for libraries__main1.zig is same. But the difference is that the liblibraries_add.so/libraries__add.dll will be dynamically linked. This means the final executable libraries__main1 will work only if it can find liblibraries_add.so/libraries__add.dll. If not, it will fail.

Thanks for reading. To be continued.

You have been zigged (series) : Writing a program in multiple files

Black Tornado — Tue, 09 Jun 2026 09:49:40 +0000

In this program, we'll write a program to find the absolute of a 32 bit signed integer. We will purposefully break the program into 2 files to see how to modularize zig codebase. Spoiler alert - its done using @import built-in.

First, lets save multiple_source_files__myabs.zig with myabs function that returns absolute value of a number. Its a very simple function.

// multiple_source_files__myabs.zig
pub fn myabs(num: i32) i32 {
    return if (num < 0) -num else num;
}

Now lets save multiple_source_files__main.zig with the following content. This outer program which contains an entry point uses the @import built-in to import the previously made multiple_source_files__myabs.zig type and call the myabs function we defined in it.

// multiple_source_files__main.zig
const std = @import("std");
const myabsType = @import("./multiple_source_files__myabs.zig");

pub fn main(init: std.process.Init) !void {
    const num: i32 = -1;
    const abs_num = myabsType.myabs(num);

    // setup stdout writer
    var buffer: [1024]u8 = undefined;
    var file_writer = std.Io.File.Writer.init(.stdout(), init.io, &buffer);
    var stdout_writer = &file_writer.interface;

    try stdout_writer.print("The absolute value of {} is {}\n", .{ num, abs_num });
    try stdout_writer.flush();
}

We don't need to compile the multiple_source_files__myabs.zig to object file first and then link it against the compilation of multiple_source_files__main.zig. Instead, we can do it in one go using zig build-exe -O ReleaseSafe multiple_source_files__main.zig and the import built-in will take care of the rest. This will work only when your myabs function and the code that uses it are written in zig. So what happens when you need to use the C ABI ? We will see it in next blog. :-)

Thanks for reading. To be continued.

You have been zigged (series) : Accessing environment variables

Black Tornado — Tue, 09 Jun 2026 03:51:23 +0000

Accessing environment variables

Environment variables are key-value pairs given to a process by the operating system right before it starts. They are mainly used to configure the process on runtime. In C/C++, the environment variables are passed to the main function as arguments. In zig, the environment variables are can be accessed from the init object which is passed to the main function as argument. Let's see how that works.

Program - Printing all inherited environment variables using zig.

To print out all the environment variables, we will utilize the environment variable iterator.

// environment_vars1.zig
const std = @import("std");

pub fn main(init: std.process.Init) !void {
    var env_vars_iterator = init.environ_map.iterator();

    // setup stdout writer
    var buffer: [1024]u8 = undefined;
    var file_writer = std.Io.File.Writer.init(.stdout(), init.io, &buffer);
    var stdout_writer = &file_writer.interface;

    while (env_vars_iterator.next()) |env_var| {
        try stdout_writer.print("{s} \n {s}\n\n", .{ env_var.key_ptr.*, env_var.value_ptr.* });
    }
    try stdout_writer.flush();
}

You can run the program using zig run environment_vars1.zig. This will print out all the environment variables to console. To build executable zig build-exe -O ReleaseSafe environment_vars1.zig

Program - Printing the value of a user selected environment variable using zig.

In this program we are going to setup a Reader which can read from stdin. We will first print out the names of all the environment variables using the iterator we used in the above program and then using aforementioned reader instance, we will let the user type in the name of an environment variable. If they entered a existing environment variable name, we will retrieve the value of that environment variable using the get function and print the value of that environment variable. If the user entered a non-existing environment variable name, we will error out using InvalidEnvVariableEntered.

// environment_vars2.zig
const std = @import("std");

pub fn main(init: std.process.Init) !void {
    // setting up stdout writer
    var stdout_buffer: [1024]u8 = undefined;
    var file_writer: std.Io.File.Writer = .init(.stdout(), init.io, &stdout_buffer);
    var stdout_writer = &file_writer.interface;

    // setting up stdin reader
    var stdin_buffer: [1024]u8 = undefined;
    var file_reader: std.Io.File.Reader = .init(.stdin(), init.io, &stdin_buffer);
    var stdin_reader = &file_reader.interface;

    try stdout_writer.print("Printing all environment variable names...\n", .{});
    var env_vars_iterator = init.environ_map.iterator();
    while (env_vars_iterator.next()) |env_var| {
        try stdout_writer.print(" {s}\n", .{env_var.key_ptr.*});
    }

    // fetch the name of env variable whose value we need to display
    try stdout_writer.print("Enter the name of an environment variable to see its value :", .{});
    try stdout_writer.flush();
    const userinput = try stdin_reader.takeDelimiterExclusive('\n');
    const userinput_trimmed = std.mem.trimEnd(u8, userinput[0..userinput.len], "\r");
    const env_var_value = init.environ_map.get(userinput_trimmed);
    if (env_var_value == null) {
        try stdout_writer.flush();
        return error.InvalidEnvVariableEntered;
    }
    try stdout_writer.print("{s} => {s}\n", .{ userinput_trimmed, env_var_value.? });
    try stdout_writer.flush();
}

You can run the program using zig run environment_vars2.zig. To build executable zig build-exe -O ReleaseSafe environment_vars2.zig.

Thanks for reading. To be continued.

You have been zigged (series) : Printing command line arguments

Black Tornado — Mon, 08 Jun 2026 17:58:40 +0000

Introduction

In this program we will accept the command line arguments passed to the program by the user and print them out one by one. In zig, the main function gets instance of a struct std.process.Init. This instance, commonly named init will contain a lot of stuff including the command line arguments. Let's dive into the program.

// argument_printer.zig
const std = @import("std");

pub fn main(init: std.process.Init) !void {
    const args = try init.minimal.args.toSlice(init.arena.allocator());
    var buffer: [1024]u8 = undefined;
    var file_writer = std.Io.File.Writer.init(.stdout(), init.io, &buffer);
    const stdout_writer = &file_writer.interface;
    try stdout_writer.print("Printing command line arguments...\n\n", .{});
    for (args) |arg| {
        try stdout_writer.print("{s}\n", .{arg});
    }
    try stdout_writer.flush();
}

Let's compile the program.

C:/learn_zig>zig build-exe -O ReleaseSafe argument_printer.zig

Now let's run the program.

C:/learn_zig>argument_printer.exe Osamu Dazai daun ebani

This will print the following content. Note that the first line is the full path of the executable.

Printing command line arguments...

argument_printer.exe
Osamu
Dazai
daun
ebani

Thanks for reading.

You have been zigged (series) : Introduction and hello world

Black Tornado — Mon, 08 Jun 2026 17:25:25 +0000

Introduction

So recently I watched the YouTube videos of Andrew Kelly (link-1, link-2) and became a fan of zig. I tried the ziglings exercises and loved the language, and now wants to get my hands dirty with zig. Thanks to friend and mentor Mr. Praseed Pai I have a set of simple C/C++ programs here (GNULinux.pdf) that I can rewrite in zig to learn. It covers simple but critical topics elegantly like going through environment variables, command line arguments, pipes, IPC etc and I think I'll enjoy this. As I'm going though this, I chose to share my journey with you. Hope you will enjoy it as me.

Prerequisites before reading this blog:

My goal is to share some zig programs with you so that you also can get your hands dirty with zig. I will not be covering what zig is and what it is trying to achieve nor what it is trying to do different from c/rust/go. You must watch Mr. Kelly's talks and interviews for understanding this. I strongly believe that receiving information from the source is better than receiving it through the grapevine.
Ziglings
Knowledge about how native programming differs from cross-platform programming using C#/Java/Python.
A little bit of exposure to C, enough to understand the interop programs that are going to come.
Look up what C ABI is if you don't know what that is. (I did spell it correctly)
You have zig compiler installed in your environment and is available in PATH

Program 01 : 3 ways of doing Hello, world!

There are three ways to do hello world in zig and let me explain. First, the program.

// helloworld.zig
const std = @import("std");

pub fn main(init: std.process.Init) !void {
    // debug print. this writes to standard error, not standard out
    std.debug.print("Hello, World! This is written using debug.print.\n", .{});

    // writing to standard out without buffer
    try std.Io.File.writeStreamingAll(.stdout(), init.io, "Hello, World! This is written using writeStreamingAll\n");

    // writing to standard out with buffer (recommended approach)
    // step 1: create a buffer array to hold string data.
    var buffer: [1024]u8 = undefined;
    // step 2: call the Writer.init method and pass in init.io.
    var file_writer = std.Io.File.Writer.init(.stdout(), init.io, &buffer);
    // step 3: strip type and take the interface so we have the option to
    // write to anything including sockets or files and not just stdout.
    var stdout_writer = &file_writer.interface;
    // step 4: use the print method to print
    try stdout_writer.print("Hello, World! This is written using Writer.print\n", .{});
    // step 5: finally, before exiting, make sure you flush the buffer to screen
    try stdout_writer.flush();
}

Lets run the program now. I'm using windows but the commands are same for all platforms.

C:/learn_zig>zig run helloworld.zig

This will run the program in debug mode. Now let's see how to build executable.

C:/learn_zig>zig build-exe -O ReleaseSafe helloworld.zig

Thanks for reading.

Pipes - Most minimal form of inter process communication

Black Tornado — Sat, 10 Jan 2026 07:28:01 +0000

Declaration: This is not AI Slop. Real human (me) wrote this. But tools including AI were used for research and learning.

Declaration: Pipes are not network programming. I just happen to start learning low level coding from pipes and hence documenting it.

When you want to transfer data between two processes, things get interesting. Operating systems doesn't allow processes to take data from another process directly, even if the two processes were of the same program, and this is a good thing. This process isolation ensures that for e.g., some image editing software running with chrome wont be able to snatch out the amazon payment you are doing in chrome. But this makes the lives of legit developers bit difficult, doesn't it ? So instead of directly accessing the insides of that running process, you and the developer of that process can agree upon what information to share and use standard tools to make everything work. This is blog 1 of learning Client server computing/network programming and today's topic is pipes.

Need to make one thing clear - programming using pipes are not network programming, its just that network programming is what I'm trying to learn and I happen to start with pipes.

Pipes can be used in the terminal and in programs to transfer data between 2 processes. It is possible to transfer data between processes of different programs when using pipes in terminal, you are probably already doing it like this

$ ls /bin | grep system | more

But in your programs, you can only use pipes for exchanging data as long as the sender and receiver are forks of the same process only. Before showing code, I will explain why.

The handles to these pipes, called anonymous pipes only exist as file descriptors in the memory space of the process that created it. A second separate process cannot access the first one's memory space to get a hold of it. So, these cannot be used for information exchange between two different processes of different programs.

#include <stdio.h>
#include <unistd.h>
#include <err.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    int pipefd[2];
    int child_pid;
    char *payload = "Hello pipes\0";
    char child_buffer;
    char child_payload[12];
    if (pipe(pipefd) == -1)
    {
        err(EXIT_FAILURE, "pipe");
    }
    child_pid = fork();
    if (child_pid == -1)
    {
        err(EXIT_FAILURE, "fork");
    }
    if (child_pid == 0)
    //  child_pid == 0 means it is child.
    //  for parent child_pid will have the child's actual non zero process id
    {
        memset(child_payload, 0, sizeof(child_payload));
        close(pipefd[1]);
        printf("Reading payload from parent...\n");
        while (read(pipefd[0], &child_buffer, 1) > 0)
        {
            strncat(child_payload, &child_buffer, 1);
        }
        printf("%s\n", child_payload);
        close(pipefd[0]);
        exit(EXIT_SUCCESS);
    }
    else
    {
        // we are going to write a message to child using
        // the write fd of the pipe (i.e, the one on index 1)
        // the one in index 0 is read end of the pipe
        close(pipefd[0]);
        printf("Writing payload to child process...\n");
        if (write(pipefd[1], payload, strlen(payload)) == -1)
        {
            err(EXIT_FAILURE, "write");
        }
        if (close(pipefd[1]) == -1)
        {
            err(EXIT_FAILURE, "close");
        }
        if (wait(NULL) == -1) /* Wait for child to exit */
        {
            err(EXIT_FAILURE, "wait");
        }
        exit(EXIT_SUCCESS);
    }
    return 0;
}

The above program forks to create 2 processes of the same program and then transfers the string "Hello pipes" from parent process to child. (If you don't understand what is a file descriptor, feel free to comment and I will try to write a blog post for it.) The program starts, then creates a pipe. The created pipe will always have 2 ends - a read end and a write end. These ends are given to the programmer as an array of 2 integer file descriptors. The first file descriptor is the read end, and the second file descriptor is the write end. Then we fork() to create a child process. The parent is the one who needs to give out data and child is the one to accept the data. This means, parent only needs to use the write fd of the pipe and child only needs to use the read fd of the pipe. Parent can safely close the read end and child can safely close the write end as they wont be using it. It is important that parent and child close the file descriptor they are not using - otherwise the program will deadlock because of [insert complex technical reason here]. After this, the parent can safely write() to the file descriptor representing the write end of the pipe and the child can read() the read end. The parent waits for the child to exit and then it itself exits.
If you would like to compile my code, save my code as main.c and run the following command in a Linux bash shell
$ gcc -o main main.c
$ ./main

Criticisms and discussions welcome..! Hope I made your brain's networking side a little bit better.