Rust came first, so people who didn't like Rust flocked to Zig as an alternative, and were keen to promote it as an alternative to Rust by criticising Rust, as wider usage would provide them more of an ecosystem to use in their own Zig programs.

People who were happy with Rust didn't have same need to criticise Zig in online spaces as Rust is the established player in the C alternatives space. (Though Rust is on the other side when compared to C once you expand the space to "all low level programming languages").

Also for people who don't care about the space at all, Rust has had years of exposure to promote fatigue, while Zig hasn't (yet).

The perception of Zig and Rust within different communities can vary, and Zig may not attract the same level of "lukewarm response" as Rust due to several factors, including their design philosophies, target use cases, and community engagement.

Zig's appeal lies in its deliberate simplicity and explicitness, offering a different path to high-performance, low-level programming compared to Rust's safety-first, more complex approach. This divergence in philosophy and implementation leads to different reception within the programming community.

This will be anecdotal. However both in the academia and in the semi-professional space, I encountered certain type of programmer who is a bit more "religiously minded" (both in the technical space and quite often in their personal beliefs too). Unix, although being a quite commercial project, its academic origins attracted a kind of followers, who believe there is a certain purity we can reach with computers or software that's not bound to the practical and economic use-cases. This forms an identity and they tend to regard programmers who are in this ecosystem as gods or prophets. The origins of Unix is also mixed with the free software movement due to both academic origins and regarded as a one continuous movement.

C language is strongly tied to Unix ecosystem. C language and current compilers give this illusion of "ultimate control" to the programmers (although C has been interpreted quite freely for the sake of optimizations). With GNU C compiler finding a niche (i.e. being a free as in beer C compiler and a userland that's not bounded by the original Unix or BSD licensing / patents) and taking off in many servers the beliefs were kind of validated.

Rust attacks those beliefs in multiple fronts:

First and foremost, Rust comes from an inherent distrust to the programmer's abilities to write secure software. Rust creates strong obstacles against writing "magic" programs that freely interpret memory. Programmers are not treated as gods but fallible mortals who needed to be guided. Many C programmers interpret this as an insult to their abilities to manually check and verify a program. Rust is no less capable than C, it has all sorts of escape hatches that can be used in performance critical parts.

Rust compiler itself and the most of the programs written in Rust are permissively licensed. This is to avoid possible issues with copyleft licenses combined with statically linked binaries. Without having a stable ABI or ability to incorporate third party libraries post-build, GPL and LGPL create hurdles that doesn't exist in the mostly dynamically compiled world of C.

Rust has a more equal regard of the operating systems, including non-POSIX ones like Windows. Despite most people in the world interact with non-POSIX APIs the most, accepting it as another step.

Rust community tries its best to create a safe space for marginalized parts of the society. Go to any Rust conference and you'll see an over-representation of LGBTQ people. This probably rubs majorly white male subset of strongly identifying C programmers up wrong way.

The community also welcomes a bunch of different ways of thinking and questioning the basics of every single decision we made when we were building the systems of today.

Zig, on the other hand doesn't attack any of those "base principles". It fixes the most annoying parts of C programming: fluid integer types, really weak type system, hostile dependency management. It still trusts the programmer 100%. The default behavior is still unsafe.

People who choose Rust are also particularly worried about the security of the programs and they would like to prove and validate the language's existence and goals. They do that by reimplementing very popular and very senior projects in Rust and compare its performance and safety against existing C projects too. Many such projects have enjoyed a long time of no competition and now there is one.

It isn't all of the objection, but there is a non-neglible amount of anti-woke people who find some weak technical reason to hate rust. It's silly but you'll be amazed in how often you see it line up when checking a random sampling of people who show up in rust threads just to make off topic complaints about rust.

EDIT: I hadn't fully gone through the comment section on this one yet and yikes it's worse about it than normal.