DEV Community: Black Tornado

You have been zigged (series) : Directory traversal 2

Black Tornado — Sun, 21 Jun 2026 09:19:16 +0000

The 20th program in GNULinux.pdf (mentioned in blog 1) traverses sub directories by changing the executing process's current working directory into that sub directory. This is not safe because if the program faults, its current working directory can be in a different one that which it was executed from. Imagine running all of this in a automated build system. The system will run subsequent commands in wrong directory.

But in zig we are using a directory Walker to walk through the contents of the directory. Zig makes if safe for us to do this automatically. The 21st program is about doing this safely and because the 20th program is already safe, we will be skipping this.

Thanks for reading. To be continued.

You have been zigged (series) : Directory traversal part 2

Black Tornado — Sat, 20 Jun 2026 17:14:34 +0000

Lets continue building the last program. In here we will be using the std.Io.Dir.walk() function to do the job. This will print all file names including the one we kept inside a sub directory.

const std = @import("std");

pub fn main(init: std.process.Init) !void {
    const my_dir = std.Io.Dir.cwd().openDir(init.io, "./dir_enumerator", .{ .follow_symlinks = false, .iterate = true }) catch {
        try std.Io.File.writeStreamingAll(.stdout(), init.io, "Failed to open directory. Exiting...\n");
        std.process.exit(1);
    };
    defer my_dir.close(init.io);

    var stdout_buffer: [1024]u8 = undefined;
    var file_writer = std.Io.File.Writer.init(.stdout(), init.io, &stdout_buffer);
    var stdout_printer = &file_writer.interface;

    var walker = try std.Io.Dir.walk(my_dir, std.heap.page_allocator);
    defer walker.deinit();

    while (true) {
        const entry = try walker.next(init.io);
        if (entry == null) break;
        try stdout_printer.print("{s} - {any}\n", .{ entry.?.path, entry.?.kind });
    }
    try stdout_printer.flush();
}

test1.txt - .file
test2.txt - .file
subdir - .directory
subdir/subdir_file.txt - .file

Thanks for reading. To be continued.

You have been zigged (series) : Enumerating files and directories

Black Tornado — Sat, 20 Jun 2026 16:58:03 +0000

To open a directory for the purposes of inspecting its contents, we can use the std.Io.Dir.cwd().openDir() function. In this program, we will list out the files and directories in the mentioned directory dir_enumerator. We will not traverse sub directories for files in this program, lets save that for next.

const std = @import("std");

pub fn main(init: std.process.Init) !void {
    const my_dir = std.Io.Dir.cwd().openDir(init.io, "./dir_enumerator", .{ .access_sub_paths = false, .follow_symlinks = false, .iterate = true }) catch {
        try std.Io.File.writeStreamingAll(.stdout(), init.io, "Failed to open directory. Exiting...\n");
        std.process.exit(1);
    };
    defer my_dir.close(init.io);
    var directory_iterator = my_dir.iterate();
    var buffer: [1024]u8 = undefined;
    var file_writer = std.Io.File.Writer.init(.stdout(), init.io, &buffer);
    var stdout_printer = &file_writer.interface;

    while (directory_iterator.next(init.io) catch unreachable) |entry| {
        try stdout_printer.print("{s} - {any}\n", .{ entry.name, entry.kind });
    }
    try stdout_printer.flush();
}

Have a dummy folder dir_enumerator and inside of it have file test1.txt, file test2.txt and sub directory subdir. Have a file subdir_file.txt inside the subdir.

The output will be

test1.txt - .file
test2.txt - .file
subdir - .directory

Thanks for reading. To be continued.

You have been zigged (series) : Forking a child process (part 2)

Black Tornado — Fri, 19 Jun 2026 14:28:11 +0000

In this blog we will continue modifying last program. We will listen to the exit code and log it to console.

const std = @import("std");

pub fn main(init: std.process.Init) !void {
    const allocator = init.arena.allocator();
    // defer init.arena.deinit();  not needed as zig will deinit main arena on exit anyway
    const args = try init.minimal.args.toSlice(allocator);
    if (args.len == 2 and std.mem.eql(u8, args[1], "--worker=true")) {
        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("Printing from worker process...\n\n", .{});
        try stdout_writer.flush();
        std.process.exit(1);
    } else {
        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("Printing from main process...\n\n", .{});
        try stdout_writer.flush();

        const argv = &.{ "./worker__main", "--worker=true" };
        var child = try std.process.spawn(init.io, .{ .argv = argv, .stdout = .inherit });
        const term = try child.wait(init.io);
        switch (term) {
            .exited => |code| {
                try stdout_writer.print("Main: Child exit code is {}\n", .{code});
            },
            .signal => |sig| {
                try stdout_writer.print("Main: OS killed child with {}\n", .{sig});
            },
            .stopped => |signal| {
                try stdout_writer.print("Main: child got stopped/suspended by signal {}\n", .{signal});
            },
            .unknown => |code| {
                try stdout_writer.print("Main: child got terminated abnormally with raw code {}\n", .{code});
            },
        }
        try stdout_writer.flush();
    }
}

We'll build using zig build-exe -O ReleaseSafe worker__main.zig and run using ./worker__main. The output will be

Printing from main process...

Printing from worker process...

Main: Child exit code is 1

Thanks for reading. To be continued,

You have been zigged (series) : Forking a child process

Black Tornado — Fri, 19 Jun 2026 14:09:00 +0000

This program is about the POSIX fork() syscall. Zig favors standard library functions std.process.spawn() and std.process.run() functions instead of using OS specific functions like fork(). The spawn and run functions use appropriate OS specific functions underneath and the code we write can stay OS agnostic. As we already saw the spawn function in blog 13, let's look at run function in this blog. The run function allows the programmer to have more control over the child process than spawn. Lets use it to run another process of the same executable. There are several reasons why one would want to do this.

Fault isolation
Security sandboxing
True hard memory limits

Lets see the code for a program that spins itself up on startup as a worker.

const std = @import("std");

pub fn main(init: std.process.Init) !void {
    const allocator = init.arena.allocator();
    // defer init.arena.deinit();  not needed as zig will deinit main arena on exit anyway
    const args = try init.minimal.args.toSlice(allocator);
    if (args.len == 2 and std.mem.eql(u8, args[1], "--worker=true")) {
        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("Printing from worker process...\n\n", .{});
        try stdout_writer.flush();
    } else {
        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("Printing from main process...\n\n", .{});
        try stdout_writer.flush();

        const argv = &.{ "./worker__main", "--worker=true" };
        _ = try std.process.spawn(init.io, .{ .argv = argv, .stdout = .inherit });
    }
}

We can build executable using zig build-exe -O ReleaseSafe worker__main.zig, which will create worker__main. When we execute it using ./worker__main, we ll see

Printing from main process...

Printing from worker process...

Thanks for reading. To be continued.

You have been zigged (series) : Calling open, read, write, close POSIX API

Black Tornado — Sun, 14 Jun 2026 21:14:24 +0000

Eventually in the future we will write a zig program that copies a file using POSIX API. Currently the API is changing fast and unfortunately we cant cover this at this point of time. Sorry.

Thanks for reading. To be continued.

You have been zigged (series) : Copying a binary file

Black Tornado — Sun, 14 Jun 2026 06:49:04 +0000

Lets explore how to read contents of a binary file and print it out in stdout. To do this we will use Dir.readFileAlloc() function. Lets first save a demo text file as test.txt in the same folder as where the program lives and have some lorem ipsum in it. (We will be using a text file to test this out, but the API will work for any binary file. Just trust me.)

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

pub fn main(init: std.process.Init) !void {
    var stderr_buffer: [1024]u8 = undefined;
    var stderr_file_writer = std.Io.File.Writer.init(std.Io.File.stderr(), init.io, &stderr_buffer);
    const stderr_writer = &stderr_file_writer.interface;

    const commandline_args = try init.minimal.args.toSlice(init.arena.allocator());
    if (commandline_args.len != 3) { // exe name, input filename and output filename
        try stderr_writer.print("Usage: filestdio_bin__main <input filename> <output filename>\n", .{});
        try stderr_writer.flush();
        return;
    }

    const file_content = try std.Io.Dir.cwd().readFileAlloc(init.io, commandline_args[1], init.gpa, .unlimited);
    defer init.gpa.free(file_content);

    try std.Io.Dir.cwd().writeFile(init.io, .{ .sub_path = commandline_args[2], .data = file_content });
}

Upon running this program using zig run filestdio_bin__main.zig -- test.txt output.txt we can see the output.txt having the contents of test.txt.

Thanks for reading. To be continued.

You have been zigged (series) : Reading text file contents

Black Tornado — Sat, 13 Jun 2026 08:33:13 +0000

Lets explore how to read contents of a text file and print it out in stdout. To do this we will use Dir.openFile() function and Reader.takeDelimiterExclusive() function. Lets first save a demo text file as test.txt in the same folder as where the program lives and have some lorem ipsum in it.

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

pub fn main(init: std.process.Init) !void {
    var stderr_buffer: [1024]u8 = undefined;
    var stderr_file_writer = std.Io.File.Writer.init(std.Io.File.stderr(), init.io, &stderr_buffer);
    const stderr_writer = &stderr_file_writer.interface;

    const commandline_args = try init.minimal.args.toSlice(init.arena.allocator());
    if (commandline_args.len != 2) { // exe name and filename
        try stderr_writer.print("Usage: filestdio_text__main <filename>\n", .{});
        try stderr_writer.flush();
        return;
    }

    const file = try std.Io.Dir.cwd().openFile(init.io, commandline_args[1], .{});

    var file_buffer: [1024]u8 = undefined;
    var file_file_reader = std.Io.File.Reader.init(file, &file_buffer);
    var file_reader = &file_file_reader.interface;
    const file_content = try file_reader.takeDelimiterExclusive('\x00');

    var stdout_buffer: [1024]u8 = undefined;
    var stdout_file_writer = std.Io.File.Writer.init(std.Io.File.stdout(), init.io, &stdout_buffer);
    const stdout_writer = &stdout_file_writer.interface;

    try stdout_writer.print("{s}", .{file_content});
    try stdout_writer.flush();
}

Upon running this program using zig run filestdio_text__main.zig -- test.txt we can see the output in terminal (the contents of test.txt).

Thanks for reading. To be continued.

You have been zigged (series) : Writing to spawned child process's stdin

Black Tornado — Thu, 11 Jun 2026 12:38:52 +0000

In this blog, we will explore how to spawn a child process and write content into its stdin.

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

pub fn main(init: std.process.Init) !void {
    var buffer: [1024]u8 = undefined;
    const argv = [_][]const u8{"sort"};
    var child = try std.process.spawn(init.io, .{ .argv = &argv, .stderr = .inherit, .stdin = .pipe, .stdout = .inherit });
    defer child.kill(init.io);
    const child_stdin = child.stdin orelse return error.MissingStdinPipe;
    var writer = std.Io.File.Writer.init(child_stdin, init.io, &buffer);
    try writer.interface.print("Ziyad\nAnand\nArjun\nRam\nHooper\n", .{});
    try writer.flush();
    child_stdin.close(init.io); // send EOF to sort command. without this sort will wait infinitly
    child.stdin = null; // set child.stdin = null (avoids a Zig 0.16 debug double-close panic)
    _ = try child.wait(init.io);
}

Running the program with zig run sortusingpipe__main.zig will print the names in ascending order.

Anand
Arjun
Hooper
Ram
Ziyad

Thanks for reading. To be continued.

You have been zigged (series) : About system function from stdlib.h

Black Tornado — Thu, 11 Jun 2026 11:47:12 +0000

The 12th program uses system function from stdlib.h. This function is not available in zig. Zig users are supposed to use std.process.run() and std.process.spawn() functions instead because its more safer. If you really really want to execute commands using shell injection you can pass the string "sh" before the command in argv array (code from blog 11) like .argv = &.{ "sh", "-c", "ls", "-l" }.

Thanks for reading. To be continued.

You have been zigged (series) : Run a child process

Black Tornado — Thu, 11 Jun 2026 11:36:30 +0000

In this blog we will see how to run a child process from a zig program. There are two std lib functions that allows us to do this - std.process.run() and std.process.spawn(). Lets see how we can use both.

Method 1: `std.process.run()`

The run function allows us to run a process without much hassle. The following program runs ls -l and prints out the output in stdout. ls is a linux command. If you are on windows, you can use dir instead.

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

pub fn main(init: std.process.Init) !void {
    const argv = [_][]const u8{ "ls", "-l" };
    const result = try std.process.run(init.gpa, init.io, .{ .argv = &argv });
    defer init.gpa.free(result.stderr);
    defer init.gpa.free(result.stdout);

    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("{s}", .{result.stdout});
    try stdout_writer.flush();
}

We can compile the program using zig build-exe runprocess__main.zig. Upon execution, this program will print the contents of current directory.

Method 2: `std.process.spawn()`

The spawn function gives us fine-grained control over the process.

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

pub fn main(init: std.process.Init) !void {
    const argv = [_][]const u8{
        "ls",
        "-l",
    };

    var child = try std.process.spawn(init.io, .{
        .argv = &argv,
        .stdin = .inherit,
        .stdout = .inherit,
        .stderr = .inherit,
    });

    _ = try child.wait(init.io);
}

We can compile the program using zig build-exe runprocessspawn__main.zig. Upon execution, this program will print the contents of current directory.

Thanks for reading. To be continued.

You have been zigged (series) : Self modifying code

Black Tornado — Thu, 11 Jun 2026 09:29:47 +0000

The 10th program in GNULinux.pdf (mentioned in blog no 1) is about self modifying code. I'm afraid I don't have the skillset to port that program to zig and AI is not producing a program that works. I'm forced to skip this one for now and revisit this later. You can checkout the GNULinux.pdf file (linked in blog no 1) for C/C++ code that does the job. Its cool.

Thanks for reading. To be continued.

DEV Community: Black Tornado

You have been zigged (series) : Directory traversal 2

You have been zigged (series) : Directory traversal part 2

You have been zigged (series) : Enumerating files and directories

You have been zigged (series) : Forking a child process (part 2)

You have been zigged (series) : Forking a child process

You have been zigged (series) : Calling open, read, write, close POSIX API

You have been zigged (series) : Copying a binary file

You have been zigged (series) : Reading text file contents

You have been zigged (series) : Writing to spawned child process's stdin

You have been zigged (series) : About system function from stdlib.h

You have been zigged (series) : Run a child process

Method 1: std.process.run()

Method 2: std.process.spawn()

You have been zigged (series) : Self modifying code

Method 1: `std.process.run()`

Method 2: `std.process.spawn()`