Unrestricted Languages One of my favorite types of challenges on this site are restricted-source challenges.  These challenges impose a computer tractable restriction that the sources of potential answers must pass.  I like these challenges so much I have been working on a golfing language designed to win at these challenges for some time now.  Now I want to extend the challenge to you.  Your task is to design a language to solve a variety of restricted source tasks.  You will time to design and implement a language, at which point changes and new additions will be non-competing and all of the submissions will go head to head in a gauntlet of restricted-source challenges.

Scoring

Before the challenge is posted I will come up with a list of simple challenges to solve and a list of source restrictions to follow.  For each matching of challenge and source restrictions your language can earn between 0 and 2 points. (there will be 10 challenges and 10 restrictions leading to 100 total combinations) A language scores 


1 point if it can complete the task with the restriction in under 150 bytes
2 points if the solution is the shortest solution of any language competing (both languages will score 2 points in the event of a tie)
0 points if they are unable to create a program that completes the task under the restriction in less than 150 bytes.


Your score will be the sum of all points earned in every possible match up. The goal is to get the highest score.  Other people may help you to golf your solutions to each challenge and improve your score.

I will reveal 4 items of each list at the time of posting and an additional 8 one week after the second answer. You will only be allowed to score 1 point (shortest submission does not count) in any matching that has both parts revealed before the the first week. This way you can get an idea of how well your language stacks up while you are working on it, but you can't design you language simply to build in all of the challenges and restrictions. 

I will include a hash of the intended categories with the question so you can be sure I do not change them during the week to advantage any party.  In addition I will not tell anyone the hidden parameters until the week is up nor compete in the challenge myself.

Pre-existing languages

This challenge is open to all pre-existing languages however if you are not the author of the language, please make your answer a community wiki so that other members of our community can contribute to the score directly.  Command line flags need not obey any restrictions however every program should be run with the same command line arguments (i.e. you should pick one and stick with it).  These do not add to your byte count.

Challenges and restrictions

Restrictions are enforced on the ASCII encoding of your binaries regardless of the code-page you use.  Some of these link to an existing question on the site from which they inherit their io requirements for challenges and source restrictions for restrictions.  You can ignore anything "banning builtins" or overriding existing meta consensuses on any of the linked challenges.

As a word of warning: do not try to rule lawyer; I know it is a competition but because there are essentially 100 different sub-challenges challenges and I simply cannot guarantee that all of them will be entirely unproblematic.  Just try to have fun.

Challenges


Sort a list of integers
print Hello, world!
Determine if parentheses are balanced
Test Primality


Restrictions


Only odd bytes (every 8th bit must be odd)
Double bytes
Bytes are in ascending order (each byte is greater than the last)
Source code is a palindrome


The remaining criteria have a sha512 hash of:

4de5eca33c6270798606cf1412820c4ce112d8b927ef02877f36795b2b15ffacca51ea598fa89b8d6bc9f4cde53810e0e7ade30e536e52e28f40a6a13841dfc5  -
Width
The interpreter is still a work in progress (I have several unused command slots still). The repo, with more documentation, can be found here.
Dennis added Width to TIO less than a minute ago: Try It Online!
Width is an esoteric stack-based language I developed recently based on ideas I first dumped in this question. It is based entirely on how wide, more or less, a letter is in a &quot;regular&quot; font. The only characters that do anything are letters, uppercase and lowercase. All other characters are ignored. I split letters up into 10 different width categories, which form the 10 different actions possible in Width:
0: i j l                     # do while counter &gt; 0
1: f r t I                   # end
2: c k s v x y z J           # 0 in commands
3: a b d e g h n o p q u L   # separator (no-op)
4: F T Z                     # push base 10 number, using left side row titles (width numbers); terminated with original char
5: A B E K P S V X Y         # 1 in commands
6: w C D H N R U             # 2 in commands
7: G O Q                     # push string literal; sets of 2 width numbers equate to index in printable ASCII; terminated with original char
8: m M                       # if top of stack
9: W                         # else

2, 5, and 6 provide access to the commands, most of which interact with the stack. More information can be found at the info.txt page in the Github repo.
This is the Python code of the interpreter. I still have several commands to add, and I'm considering how to work with error-handling, but otherwise it should be complete. (I'm also going to add a flag at some point to allow testing with a more abstract syntax, because otherwise this language is a giant pain to work with)
import sys
import math
import numbers
import functools

try:
    file = sys.argv[1]
except IndexError:
    file = &quot;source.wide&quot;

with open(file) as f:
    source = f.read()

translation = (&quot;ijl&quot;, &quot;frtI&quot;, &quot;cksvxyzJ&quot;, &quot;abdeghnopquL&quot;, &quot;FTZ&quot;, &quot;ABEKPSVXY&quot;, &quot;wCDHNRU&quot;, &quot;GOQ&quot;, &quot;mM&quot;, &quot;W&quot;)
chars = &quot;&quot;.join(sorted(&quot;&quot;.join(translation)))
strings = &quot;&quot;&quot; !&quot;#$%&amp;'()*+,-./0123456789:;&lt;=&gt;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\n\t&quot;&quot;&quot;


def trans(letter):
    for each in translation:
        if letter in each:
            return translation.index(each)

COMMAND = &quot;COMMAND&quot;
COMMANDS = (2, 5, 6)
NUMBER = &quot;NUMBER&quot;
STRING = &quot;STRING&quot;
DO = &quot;DO&quot;
IF = &quot;IF&quot;
ELSE = &quot;ELSE&quot;
END = &quot;END&quot;
SEPARATOR = &quot;SEPARATOR&quot;


class Token:
    def __init__(self, val, type_):
        self.val = val
        self.type = type_


class Lexer:
    def __init__(self, src):
        self.src = src
        self.pos = 0
        self.char = self.src[self.pos]

    def read(self):
        if self.char is None:
            return None

        command = trans(self.char)

        if command == 0:
            self.advance()
            return Token(0, DO)
        elif command == 1:
            self.advance()
            return Token(1, END)
        elif command == 3:
            self.advance()
            return Token(3, SEPARATOR)
        elif command == 4:
            return self.read_num()
        elif command == 7:
            return self.read_str()
        elif command == 8:
            self.advance()
            return Token(8, IF)
        elif command == 9:
            self.advance()
            return Token(9, ELSE)
        else:
            return self.read_cmd()

    def advance(self):
        self.pos += 1

        try:
            self.char = self.src[self.pos]
        except IndexError:
            self.char = None

    def read_num(self):
        delim = self.char
        self.advance()

        res = &quot;&quot;
        while self.char is not None and self.char != delim:
            res += str(trans(self.char))
            self.advance()

        self.advance()

        return Token(int(res), NUMBER)

    def read_str(self):
        def read_char():
            res_ = str(trans(self.char))
            self.advance()
            res_ += str(trans(self.char))
            self.advance()
            try:
                return strings[int(res_)]
            except IndexError:
                return &quot; &quot;

        delim = self.char
        self.advance()

        res = &quot;&quot;
        while self.char is not None and self.char != delim:
            res += read_char()

        self.advance()

        return Token(res, STRING)

    def read_cmd(self):
        command = &quot;&quot;
        while self.char is not None and trans(self.char) in COMMANDS and len(command) &lt;= 4:
            command += str(COMMANDS.index(trans(self.char)))
            self.advance()

        return Token(command, COMMAND)

source = &quot;&quot;.join(filter(lambda c: c in chars, source))

stack = []
backburner = []
counter = 0


def set_counter(val):
    global counter
    counter = int(val)

    if counter &lt; 0:
        counter = 0


def set_stack(val):
    global stack
    stack = val


def num_input():
    inp = input()
    try:
        stack.append(int(inp))
    except ValueError:
        try:
            stack.append(float(inp))
        except ValueError:
            pass


def flip_ends():
    if len(stack) &gt; 1:
        stack[0], stack[-1] = stack[-1], stack[0]


def clear_stack():
    global stack
    stack = []


def reload_stack(is_top):
    global backburner, stack

    if is_top:
        stack.extend(backburner)
    else:
        stack = backburner + stack

    backburner = []


# https://stackoverflow.com/a/15285588/7605753
def is_prime(n):
    if n == 2 or n == 3:
        return True
    if n &lt; 2 or n % 2 == 0:
        return False
    if n &lt; 9:
        return True
    if n % 3 == 0:
        return False
    r = int(math.sqrt(n))
    _f = 5
    while _f &lt;= r:
        if n % _f == 0:
            return False
        if n % (_f + 2) == 0:
            return False
        _f += 6
    return True


def error():
    raise Exception

commands = {
    &quot;0&quot;: lambda: stack.append(stack[-1]),
    &quot;1&quot;: lambda: stack.append(stack.pop(-2)),
    &quot;2&quot;: lambda: stack.pop(),
    &quot;00&quot;: lambda: set_counter(stack[-1]),
    &quot;01&quot;: lambda: stack.append(len(stack)),
    &quot;02&quot;: lambda: stack.append(input()),
    &quot;10&quot;: num_input,
    &quot;11&quot;: lambda: stack.append(str(stack.pop())),
    &quot;12&quot;: lambda: stack.append(int(stack.pop())),
    &quot;20&quot;: lambda: set_counter(counter + 1),
    &quot;21&quot;: lambda: set_counter(counter - 1),
    &quot;22&quot;: lambda: print(stack.pop()),
    &quot;000&quot;: lambda: stack.append(float(stack.pop())),
    &quot;001&quot;: lambda: stack.append(-stack.pop()),
    &quot;002&quot;: lambda: stack.append(not stack.pop()),
    &quot;010&quot;: lambda: stack.append(stack.pop(-2) + stack.pop()),
    &quot;011&quot;: lambda: stack.append(stack.pop(-2) - stack.pop()),
    &quot;012&quot;: lambda: stack.append(stack.pop(-2) / stack.pop()),
    &quot;020&quot;: lambda: stack.append(stack.pop(-2) // stack.pop()),
    &quot;021&quot;: lambda: stack.append(stack.pop(-2) * stack.pop()),
    &quot;022&quot;: lambda: stack.append(stack.pop(-2) % stack.pop()),
    &quot;100&quot;: lambda: stack.append(math.factorial(stack.pop())),
    &quot;101&quot;: lambda: stack.append(str(stack.pop(-2)) + str(stack.pop())),
    &quot;102&quot;: lambda: stack.append(math.pow(stack.pop(-2), stack.pop())),
    &quot;110&quot;: lambda: stack.append(math.sqrt(stack.pop())),
    &quot;111&quot;: lambda: stack.append(math.log(stack.pop(-2), stack.pop())),
    &quot;112&quot;: lambda: stack.append(~stack.pop()),
    &quot;120&quot;: lambda: stack.append(stack.pop(-2) | stack.pop()),
    &quot;121&quot;: lambda: stack.append(stack.pop(-2) &amp; stack.pop()),
    &quot;122&quot;: lambda: stack.append(stack.pop(-2) &lt;&lt; stack.pop()),
    &quot;200&quot;: lambda: stack.append(stack.pop(-2) &gt;&gt; stack.pop()),
    &quot;201&quot;: lambda: stack.append(stack.pop(-2)[stack.pop()]),
    &quot;202&quot;: lambda: stack.append(str(stack.pop(-2)) * stack.pop()),
    &quot;210&quot;: lambda: stack.append(counter),
    &quot;211&quot;: lambda: set_counter(stack.pop()),
    &quot;212&quot;: lambda: stack.extend(list(str(stack.pop()))),
    &quot;220&quot;: flip_ends,
    &quot;221&quot;: lambda: stack.append(len(stack[-1])),
    &quot;222&quot;: lambda: print(stack[-1]),
    &quot;0000&quot;: lambda: stack.reverse(),
    &quot;0001&quot;: lambda: stack.sort(),
    &quot;0002&quot;: lambda: stack.append(stack[counter]),
    &quot;0010&quot;: lambda: stack.append(stack[stack.pop()]),
    &quot;0011&quot;: 0,
    &quot;0012&quot;: 0,
    &quot;0020&quot;: lambda: stack.append(sum(n for n in stack if isinstance(n, numbers.Number))),
    &quot;0021&quot;: lambda: stack.append(functools.reduce(lambda x, y: x*y, [n for n in stack if isinstance(n, numbers.Number)], 1)),
    &quot;0022&quot;: 0,
    &quot;0100&quot;: lambda: (backburner.extend(stack), clear_stack()),
    &quot;0101&quot;: lambda: reload_stack(True),
    &quot;0102&quot;: lambda: reload_stack(False),
    &quot;0110&quot;: lambda: backburner.append(stack.pop()),
    &quot;0111&quot;: lambda: backburner.append(list(stack.pop())),
    &quot;0112&quot;: lambda: stack.pop().split(stack.pop()),
    &quot;0120&quot;: lambda: stack.append(backburner[-1]),
    &quot;0121&quot;: lambda: (lambda depth=stack.pop(): (set_stack(stack[-depth:]), backburner.append(stack[:depth])))(),
    &quot;0122&quot;: lambda: (lambda depth=stack.pop(): (set_stack(stack[:-depth]), backburner.append(stack[depth:])))(),
    &quot;0200&quot;: lambda: set_stack([stack.pop().join(stack)]),
    &quot;0201&quot;: lambda: set_stack([&quot;&quot;.join(stack)]),
    &quot;0202&quot;: lambda: (lambda depth=stack.pop(-2): set_stack(stack[-depth:] + [stack.pop().join(stack[:depth])]))(),
    &quot;0210&quot;: lambda: (lambda depth=stack.pop(): set_stack(stack[-depth:] + [&quot;&quot;.join(stack[:depth])]))(),
    &quot;0211&quot;: 0,
    &quot;0212&quot;: 0,
    &quot;0220&quot;: lambda: stack.append(stack.pop().split(stack.pop())),
    &quot;0221&quot;: lambda: stack.append(stack.pop().split(&quot;, &quot;)),
    &quot;0222&quot;: 0,
    &quot;1000&quot;: lambda: stack.append(is_prime(stack[-1])),
    &quot;1001&quot;: lambda: stack.append((lambda s=stack.pop(): s == s[::-1])()),
    &quot;1002&quot;: lambda: stack.append(1 / stack.pop()),
    &quot;1010&quot;: lambda: stack.append(stack.pop() - 1),
    &quot;1011&quot;: lambda: stack.append(stack.pop() + 1),
    &quot;1012&quot;: lambda: stack.append(stack.pop() * 2),
    &quot;1020&quot;: lambda: stack.append(stack.pop() / 2),
    &quot;1021&quot;: lambda: stack.append(stack.pop() ** 2),
    &quot;1022&quot;: lambda: float(&quot;.&quot; + str(stack.pop())),
    &quot;1100&quot;: lambda: stack.append(stack.pop() == stack.pop()),
    &quot;1101&quot;: lambda: stack.append(stack.pop() != stack.pop()),
    &quot;1102&quot;: lambda: stack.append(stack.pop() &gt; stack.pop()),
    &quot;1110&quot;: lambda: stack.append(stack.pop() &lt; stack.pop()),
    &quot;1111&quot;: lambda: stack.append(stack.pop() &gt;= stack.pop()),
    &quot;1112&quot;: lambda: stack.append(stack.pop() &lt;= stack.pop()),
    &quot;1120&quot;: lambda: stack.append(stack.pop() in stack),
    &quot;1121&quot;: lambda: stack.append(stack.pop() in backburner),
    &quot;1122&quot;: lambda: stack.append(stack.pop() == counter),
    &quot;1200&quot;: lambda: stack.append(stack.pop() in stack.pop()),
    &quot;1201&quot;: lambda: stack.append(stack.pop(-2).find(stack.pop())),
    &quot;1202&quot;: 0,
    &quot;1210&quot;: 0,
    &quot;1211&quot;: 0,
    &quot;1212&quot;: lambda: stack.append(stack.pop().lower()),
    &quot;1220&quot;: lambda: stack.append(stack.pop().upper()),
    &quot;1221&quot;: lambda: stack.append(ord(stack.pop())),
    &quot;1222&quot;: lambda: stack.append(chr(stack.pop())),
    &quot;2000&quot;: lambda: stack.append(math.floor(stack.pop())),
    &quot;2001&quot;: lambda: stack.append(math.ceil(stack.pop())),
    &quot;2002&quot;: lambda: stack.append(round(stack.pop())),
    &quot;2010&quot;: lambda: stack.append(abs(stack.pop())),
    &quot;2011&quot;: 0,
    &quot;2012&quot;: 0,
    &quot;2020&quot;: lambda: stack.append(len(stack.pop())),
    &quot;2021&quot;: 0,
    &quot;2022&quot;: 0,
    &quot;2100&quot;: lambda: stack.append(min(stack)),
    &quot;2101&quot;: lambda: stack.append(max(stack)),
    &quot;2102&quot;: lambda: stack.append(stack.count(stack.pop())),
    &quot;2110&quot;: lambda: stack.append(sum(stack) / len(stack)),
    &quot;2111&quot;: 0,
    &quot;2112&quot;: 0,
    &quot;2120&quot;: 0,
    &quot;2121&quot;: 0,
    &quot;2122&quot;: 0,
    &quot;2200&quot;: lambda: stack.append(stack.pop(-3).replace(stack.pop(-2), stack.pop())),
    &quot;2201&quot;: lambda: stack.append(stack.pop(-3).replace(stack.pop(-2), stack.pop(), 1)),
    &quot;2202&quot;: lambda: stack.append(stack.pop(-2).replace(stack.pop(), &quot;&quot;)),
    &quot;2210&quot;: lambda: stack.append(stack.pop(-2).replace(stack.pop(), &quot;&quot;, 1)),
    &quot;2211&quot;: 0,
    &quot;2212&quot;: lambda: stack.append(eval(stack.pop())),
    &quot;2220&quot;: lambda: stack.append(eval(input())),
    &quot;2221&quot;: lambda: print(stack[-1]),
    &quot;2222&quot;: lambda: error()
}


def run_cmd(name):
    global stack, counter, backburner

    state = {
        &quot;stack&quot;: list(stack),
        &quot;counter&quot;: counter,
        &quot;backburner&quot;: list(backburner)
    }

    # TODO: unknown command

    try:
        commands[name]()
    except IndexError:
        stack = state[&quot;stack&quot;]
        counter = state[&quot;counter&quot;]
        backburner = state[&quot;backburner&quot;]


class AST:
    pass


class Main(AST):
    def __init__(self):
        self.nodes = []


class Do(AST):
    def __init__(self, node):
        self.node = node


class If(AST):
    def __init__(self, first, second):
        self.first = first
        self.second = second


class Literal(AST):
    def __init__(self, val):
        self.val = val


class Command(AST):
    def __init__(self, val):
        self.val = val


class Parser:
    def __init__(self, lexer):
        self.lexer = lexer
        self.token = None

    def parse(self):
        pgm = Main()
        self.token = self.lexer.read()

        while self.token is not None and self.token.type != END and self.token.type != ELSE:
            if self.token.type == DO:
                pgm.nodes.append(Do(self.parse()))

            elif self.token.type == NUMBER or self.token.type == STRING:
                pgm.nodes.append(Literal(self.token.val))

            elif self.token.type == IF:
                first = self.parse()

                if self.token.type == ELSE:
                    second = self.parse()
                else:
                    second = None

                pgm.nodes.append(If(first, second))

            elif self.token.type == COMMAND:
                pgm.nodes.append(Command(self.token.val))

            self.token = self.lexer.read()

        return pgm


class Interpreter:
    def __init__(self, tree):
        self.tree = tree

    def visit(self, node):
        method_name = &quot;visit_&quot; + type(node).__name__
        visitor = getattr(self, method_name.lower())
        return visitor(node)

    def interpret(self):
        self.visit(self.tree)

    def visit_main(self, node):
        for each in node.nodes:
            self.visit(each)

    def visit_do(self, node):
        while counter:
            self.visit(node)

    def visit_if(self, node):
        if stack[-1]:
            self.visit(node.first)
        elif node.second:
            self.visit(node.second)

    def visit_literal(self, node):
        stack.append(node.val)

    def visit_command(self, node):
        run_cmd(node.val)


if source == &quot;&quot;:
    with open(&quot;info.txt&quot;) as f:
        info = f.read()

    print(info)
else:
    main = Parser(Lexer(source)).parse()

    interpreter = Interpreter(main)
    interpreter.interpret()

    try:
        sys.exit(stack[-1])
    except IndexError:
        pass