Category:Zig

Zig
This programming language may be used to instruct a computer to perform a task.

Official website

Execution method:	Compiled (machine code)
Garbage collected:	No
Parameter passing methods:	By value
Type safety:	Unsafe
Type strength:	Strong
Type compatibility:	Nominative
Type expression:	Explicit
Type checking:	Static
Lang tag(s):	zig
See Also:	Zig on the HOPL

Listed below are all of the tasks on Rosetta Code which have been solved using Zig.

Zig is an open-source programming language designed for robustness, optimality, and clarity.

Zig is under active development at its Github repository. Solutions for RosettaCode tasks can also be found in the zig-rosetta repository.

Features

From the official website:

• Manual memory management. Memory allocation failure is handled correctly. Edge cases matter!
• Zig competes with C instead of depending on it. The Zig Standard Library does not depend on libc.
• Small, simple language. Focus on debugging your application rather than debugging your knowledge of your programming language.
• A fresh take on error handling that resembles what well-written C error handling looks like, minus the boilerplate and verbosity.
• Debug mode optimizes for fast compilation time and crashing with a stack trace when undefined behavior would happen.
• ReleaseFast mode produces heavily optimized code. What other projects call "Link Time Optimization" Zig does automatically.
• ReleaseSafe mode produces optimized code but keeps safety checks enabled. Disable safety checks in the bottlenecks of your code.
• Generic data structures and functions.
• Compile-time reflection and compile-time code execution. No preprocessor.
• Concurrency via coroutines. Async/await is thread-safe, non-blocking, and makes no syscalls, and therefore available in freestanding mode. You can multiplex coroutines onto a thread pool in userland for M:N concurrency.
• Import .h files and directly use C types, variables, and functions.
• Export functions, variables, and types for C code to depend on. Automatically generate .h files.
• Optional type instead of null pointers.
• Order independent top level declarations.
• Friendly toward package maintainers. Reproducible build, 3-step bootstrapping process.
• Cross-compiling is a first-class use case.