Read command line arguments


I’m looking for a simple way to read the command line arguments, passed to my program. I don’t want to use a full fledged command line parser, since this program is for personal use only and I hope to learn zig a little more with this approach.

Is there a zig equivalent to argc and *argv[] like in C?

Take a look at std.process.args() and related. The source files for zig’s standard library are very easy to follow. Mine are located at homebrew/Cellar/zig/0.9.1/lib/zig/std.

thank you for your reply.
I struggle to do it right. To be honest, I’m a little bit frustrated, I’m sure this is an easy task, but the lack of documentation makes this really hard.

var args = std.process.args(); //why does this only compile with "var"??
_ = args.skip(); //to skip the zig call

const allocator = std.heap.page_allocator;
const file_path = try; 

but the compiler want’s me to remove the try before, but why?

Note: English is not my native language therefore i always struggled to write English but i tried my best to explain you if you get confused let me know :slight_smile:

Ok let me explain to you why it only compiles using var by a simple example.

const Student = struct {
    name: []const u8,

    pub fn init() Student {
        return Student{.name = undefined};

    pub fn setName(self: *Student, name: []const u8) void { = name;

pub fn main() !void {
    var student1 = Student.init();

In the above example method setName sets the member name therefore inorder to change the member of itself it needs to take a mutable pointer to itself. But if you decalre a student1 with const it will be become immutable so when you call student1.setName it will be passed as *const Student (immutable) where setName expects *Student (mutable).

In this case std.process.args() returns a ArgIterator here is the actual code of it

For second problem: Why compiler wants you to remove try keyword?

try keyword is used when a function returns either an error or a value. Which means when you use const val = try someFun() it basically means “if someFunc() returns an error catch it and return it to the caller otherwise store the actual value to val”

In your case next() returns an optional value.
So to unwrap the actual value you can do const file_path =; Notice .? at the end which basically means if next() returns a value give me that value otherwise panic with the message attempt to use null value

I hope i explain to you properly.

Doc Links:
try keyword


An alternative is to use std.process.argsAlloc() so that you can allocate a copy of the argv as an array of strings, which might be easier to iterate over.

I wrote a library for argument parsing: GitHub - sam701/zig-cli: A simple package for building command line apps in Zig The design is inspired by the urfave/cli golang library.


Sorry to play necromancer on this thread, but this forum post continues to be the first thing that comes up when I search the Web for “zig args”, so I thought it would be nice to have a simple, complete, working example.

No allocations (won’t work on Windows or WASI)

Uses std.os.argv (prepopulated on program startup):

const std = @import("std");

pub fn main() !void {
    std.debug.print("There are {d} args:\n", .{std.os.argv.len});
    for(std.os.argv) |arg| {
        std.debug.print("  {s}\n", .{arg});

Or with allocations

This uses std.process.argsAlloc() to parse the args into a handy array of strings:

const std = @import("std");

pub fn main() !void {
    // Get allocator
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    // Parse args into string array (error union needs 'try')
    const args = try std.process.argsAlloc(allocator);
    defer std.process.argsFree(allocator, args);

    // Get and print them!
    std.debug.print("There are {d} args:\n", .{args.len});
    for(args) |arg| {
        std.debug.print("  {s}\n", .{arg});

Building and running either version:

As separate steps:

$ zig build-exe arg-test.zig

$ ./arg-test foo bar baz
There are 4 args:

As a single step (what I usually do while developing):

$ zig run arg-test.zig -- foo bar baz
There are 4 args:

If you are on Linux or MacOS you can use std.os.argv that is an array of zero-terminated strings. No need for allocations.


It’s not a big loss though to do a few allocs once per execution of the CLI app to keep it portable across platforms?

1 Like

To each their own. :slight_smile: Modern Windows (v10, v11) come with Linux VM under the name WSL (Windows Subsystem Linux). Reduces the pressure to support Windows API.

1 Like

Great point! (And that’s what I’d personally want most of the time, too.) Thanks!
Editing my answer to include that example as well so people have options.