The problem statement

There's no definition of what it means for two strings to be "isomorphic" (not in comments, nor even the review request itself), so readers have to deduce which meaning of the word is intended by inspection of the source code. That's not ideal. Saying that it's a translation of code from some other language isn't really helpful unless that other code is well-known amongst the C++ community.

Translation from Java

This code looks like it is Java code that has been syntactically rewritten; it doesn't look like idiomatic C++ code. For example, parallel indexing of the two strings rather than simply iterating a zip-view looks very Java to me.

Interface

Because this is a template, it will bind only to std::string_view classes, requiring callers to perform that conversion explicitly. It would be more convenient if it were more general, accepting arguments that can both be converted to a common string-view type. Then we could call with a std::wstring and a wchar_t const *, for example.

Data types

It's quite likely that this will be used for Char = char, where the overhead of std::unordered_map is going to be quite significant compared to a simple std:array for the mapping. Consider specialising the representation for Char types that have a small range. Even for wider types, real-life texts tend to use characters that are clustered in the code-point range (e.g. in Unicode, texts that use characters from more than a couple of Unicode blocks are rare), so you might choose a two-level structure for mapping from characters (probably a worthwhile utility class of its own).

Map interface

The standard map classes have insert() and try_emplace() members that test for existence, which we could use instead of the separate contains():

            if (mapping1.try_emplace(chs, chz).first->second != chz) {
                return false;
            }

            if (mapping2.try_emplace(chz, chs).first->second != chs) {
                return false;
            }

I might consider a small helper to make those firsts and seconds more palatable:

            static auto const bool insert_or_check =
                [](auto map, auto key, auto value)
                {
                    auto const it = map.try_emplace(key, value).first;
                    auto const& actual = it->second;
                    return actual == value;
                };

            if (!insert_or_check(mapping1, chs, chz) || !insert_or_check(mapping2, chz, chs)) {
                return false;
            }

Demo program

The demo program doesn't seem to know whether it's a usage example or a set of unit tests. If it's to be an example, I'd expect it to be more flexible, probably comparing two command-line arguments, and have more human-friendly output (even something as simple as std::cout << std::boolalpha). If it's a unit-test, I would expect it to actually confirm whether the results matched expectations, and return appropriate success/fail exit code.

It includes <string> but never uses it, and declares alias names with using that are never used. Also, there's a duplicate using for is_isomorphic.

If it's intended to be a test suite, then there are some cases that haven't been considered: empty strings and unequal-length strings for starters. A more advanced test would exercise non-default character traits on the views (the usual simple example is a traits that compares case-insensitively according to the "C" locale). Note that you'll have to replace the character equality check with one that uses the traits object's comparison method for this to work, and also use that for the maps' comparison parameters.