PC UASM (point coded universal assembly)
Features.
Code Structure
Standard math operators rest done with dot functions and data manipulation functions.
V for variable and GV for global variable, an Integer for type, a character a for specific like 8 bit float for example and an integer for which variable.
so v1a1 would be the first 8 bit integer variable.
if I said a variable equalled a non compatible piece of data some times i can convert it with <<(settings)
if I wrote v1a1=; I would close that variable slot also if I wrote v1a1,v1a2=1 then both would be set to 1. LV type variables and functions are for collections of variables and lva1 would have to
be defined if it were to be used with the 1 at the end representing the first variable in the list of variables.
<<(config data) is my variable manipulator tool(which can have it library expanded) useful for extended data play like for doing perl level manipulation but to more than just strings.
;; close point of code and leave useful for garbage collection.
;;; leave but don't close useful for memory optimisation and leaving processes running that close when they are ready this can help parallel thread optimisation without actually having
to work separate threads with a more harder scheme but needless to say you could wait for a variable to up date before closing or moving on that comes from another process hence parallel
programming in a backward way but very useful and true parallel programming never the less.
starting with () like (v1a2,v1a4) you can pass data from the call to variables of your point code you can also say (dv,v1a1, dv) dv being dummy variable so at that instance certain data is
not passed.
; close code sentence
f1 F2 ect function calls (most of the naming scheme is non case sensitive)
upto12letter.lowerdir.f3(config) is how you would address your function/code point nor directory name must be more than 12 letters or use space.
Where you start is at the library calls which can be delayed and included only when a process needs it but it is declared with one or more start points for one or more similar programs.

Other features..
Core libraries are based on UNIASM point codes at a low system capability(for compatibility functionality) + extensions for better platform specific ASM and extensions involving new data types and new data type manipulation config possibilities.
When compiled you end up with flat and clumped UNIASM and ASM which is like ASM version of a machine code file so overall flat from library compilation but not fully to machine coderepetition and near in the code of the library is auto tagged for memory optimisation during the first stage.
The aim is to find the optimal level of code flatness and objectification/clumping.
library wise you have your core libraries using base UNIASM and adding ASM extensions but each core function is flat it has no shared subroutines however sub routine code repetition in the compile will be tagged to optimise the issue.
At this stage the UNI ASM And the ASM is turned into fully platform specific ASM flattened out form.
This Flat ASM is optimised and compiled to a bex file binary executable.
It is executed in a container package where a modified offline variant of HTML works this executable and bex machine code has direct access
To the system. the dll's or libraries it extends to beyond the standard access and container extensions require are registered and is easily obtainable information for the software consumer.
To get the best results the compiler need quality compiler data on any new extensions.
When programming you can check your point code for a recommendations report based on if it knows of a speed ups or knows somehow that it could probably be faster and it may know roughly what you should be researching in good code practice.
Actually taking a lot of English out of the IDE foreground but leaving notation accessible is a good idea.
you can call from core libraries and include other libraries or steal from other libraries with a point code dependency checker to see what your chances are.
If you include a library or parts of a core library and no other library so you can get away with just extracting points and their dependencies you don't need the whole library.

Benefits
It's easier than C to port many programs can simply be ported with no change to the code base if it's written completely in UNI ASM.
performance wise it's on par with C depending on how compatible you want it compared to how well you want it to make use of your wider system functionality.
Excellent and simplified garbage collection on par with C.
Low code density relative to productivity lower than C.
Very extensible in terms of data manipulation functionality at what can be tuned to optimal use of resources more adept than perl.
Can work with machine level data types and also work with more developed data types.
Easy to get started with.
Less bumph in the way of real code yet tagged notation is readily accessible and usable.
You could easily extend to variables and data manipulation functions so that it worked better with maths or any type of data analytic functionality or you could efficiently manage Data files in a way that would be on par with Julia but that could compile to more efficient machine code.
Is faster easier to code and closer to bare metal than using WASM.
Could allow for many at least small games to run on any platform with out changing any development code and the games would run a lot faster than if written for Java byte code.
It could be a place for starting efficient coding.
If just working in a UASM standard once enough net data after programmers have written about such will be easier for AI like GPT 3 to write accurate code in due to a higher degree of standardised code form and naming schemes.

Disadvantages
Compiler work with extensions could take a bit of man hours perfecting compared to working in C but once done then less maintenance is required so it would catch up.
Sometimes these extensions would need container ability extensions but not always.
New and unfounded.
Due to the level of direct machine access it might not be that safe compared to if done it in web code or for java byte code or WASM.