C and C++ have been around for a long time and have evolved over decades. Although powerful and industry-proven, they have many known drawbacks which have inspired many people to have a go at developing replacement or alternative languages in the same design space. Here are the ones I know about.
Note: It is debated what attributes define a "systems" language. Most people would agree that it should be statically-typed, compiled to machine code and able interact with machine-level data types in some way. Some people would regard garbage collection as a disqualifier. Nonetheless, I have included languages that may not fit everyone's strict understanding of what a "systems" language is since there is no universal agreement.
Rust is one of the most mature new systems languages. It's claim to fame is the linear/affine type system and borrow checker which allow safe compile-time memory management and race-free multithreaded programming. It has ML-style sum types and pattern matching. It has a powerful, token-oriented procedural macro system. As new languages go, Rust is probably the most complex, and it continues to evolve as new innovations are brought to the borrow checker. It was originally developed by Graydon Hoare at Mozilla for writing the Servo browser.
Go was developed at Google by some of the original Bell Labs researchers behind C, Unix and Plan 9, e.g. Ken Thompson and Rob Pike. It is quite a mature language and is widely used in industry. The language seems to be aimed at writing network services and has extensive support for network programming in the standard library. It has garbage collection which cause some people to doubt its credentials as a systems language. It has built-in CSP concurrency features inspired by their previous language Limbo. It recently added support for type-generic programming which was resisted for some time due to complexity concerns.
Zig is developed by Andrew Kelley. It has a powerful compile-time evaluation engine that can compute at compile-time without seperate compile and run steps, as an alternative to a macro system or preprocessor. Instead of traditional generics it uses type variables and compile-time generation of struct types to create generic code. The compiler bundles a full copy of LLVM, Clang and various C standard libraries which allow it to cross-compile C and C++ code out of the box to any supported platform. The standard library does not have a global memory allocator and encourages a pattern of passing allocator interfaces to sub-components, which looks quite tedious but allows fine-grained control of memory management.
Hare is developed by the prolific C programmer Drew DeVault. It aims to be a C replacement language, while its syntax is somewhat different. The style of the language is very minimalist. There appears to be a lot of attention to detail and they are writing a formal specification, and like to point fun at Rust for not having one. They are developing an operating system in Hare to stress test the language.
Carbon is being developed by a team at Google headed by Chandler Carruth, who also works on Clang and LLVM. It aims to be 100% compatible with existing C++ code while using a different Rust-style syntax. It automatically generates C++ header files for linking with Carbon code.
D has been around for quite a while and is often overlooked. The syntax is very similar to C++. It was invented by Walter Bright who developed the Digital Mars C and C++ compilers. D has optional garbage collection. It has powerful compile-time evaluation which was a precursor to C++11's constexpr and Zig's comptime.
C3 aims to be a C replacement while remaining as close to C as possible.
Nim is a compiled, statically-typed Python-style language.
Crystal is a compiled Ruby-style language which aims to combine Ruby's easy of use with the runtime efficiency of C.
Swift was developed at Apple to replace Objective C for developing Mac OS and iOS applications. It has automatic memory management based on reference counting.
I know very little about Odin. It appears to be targeted at game development and has some industry use already.
Jai currently exists only as a series of videos produced by Jonathan Blow. There is no official website or documentation (except a community-maintained wiki) and the language appears to be developed in an ad-hoc manner in parallel with games developed using the language. It features automatic transformation of array-of-structs to struct-of-arrays for efficient SIMD processing, which is important for game development.
Like Rust, Vale uses a single-ownership model with borrow references for managing and sharing memory. Unlike Rust, it uses "generational references" to dynamically check that borrow references are still valid when they are dereferenced. The idea for this technique originally came from Entity Component Systems used in game development. They are planning to add static analysis of borrows to reduce the number of runtime checks.
Myrddin has type inference, sum types and pattern matching like Standard ML. It's like ML and C had a baby. It has manual memory management and does not appear to have any static memory-safety checking. It aims for simplicity and I think it achieves it.