This is a flat version of a UI system for an interactive UI Uscript is a very long term project. Work in progress. Uscript is a self-defining universal language Prerequisites are 'capable 2D surface perception' and 'particle physics level of tech' . For more about the concept, goal, and previous versions check out the pdfs from previous 'failed attempts' on the main page dscript.org (they 'failed' because it it grew too large to manage and became a spaghettified mess of edits) This is the third pass. Previous versions imploded under the weight of cluttered folders, flat files, dependency mistakes, etc... So I built a framework for the development process It has already started slowly creeping up into 'language' from the lower levels of math / physics/ procedural . There is a full interactive UI for designing pages There is a markup language, image drawing system, modular library of symbols, modular bracketing system, etc.. But I don't think it's web-safe. Too many file operations (create, delete, edit functions lal over). It's probably exploitable by bad actors so I only post a flat version on my website github.com/vastencn/Uscript documentation minimal and missing chunks. Feel free to ask me if you have any questions m@dscript.org

1. Math
   Obvious first step. numbers and basic arithmetic are super easy to define visually from scratch
2. Procedural
   With math it is then easy to define sequence of operations, loops, brackets, arrays, etc..
3. Geometry
   Geometry is easily defined using some constants like pi, equations like a²+b²=c², functions like sin(), cos(), etc..
4. Calculus
   Using functions and arrays we can use geometric concepts to define slopes, areas under curves, etc..
5. Physics
   Starting with fundamental particles, a table of mass values is universal (not in unit values, units are arbitrary... but ratios between the particles is universal). With particles we can then define units like distance, time, forces etc.. as well as molecules, interactions, etc..
6. Astronomy
   Using physics we can define the other side of the universal spectrum. The very small is universal (particles, forces, etc...) and the very large is also universal (Astronomy). So we can define stars, planets, blackholes, galaxies, etc... (funnily, what is not universal is all the things that seem most significant in our lives, the human scale is not universal. I suppose we find ourselves in this range precisely because this is where permutations and possibilities are so vast.)
7. Communication and Abstraction
   At this point move on to building communication tools for exchanging ideas, asking questions, etc... The building blocks established in previous layers can be used directly, or as abstractions. Establish ways to abstract with metaphor, analogy, etc... We can create things akin to 'x is like y', 'x is y-ish' etc...
8. Plug-ins
   Plug in other universal definition from visual example. Add other methods for defining from scratch.

I have started trying to properly mentally adopt base 16 so I can use it more fluently in designing Uscript.

I started using a new finger counting system, simply make thumbs worth 4, so that I can count to 16 on my fingers
(considering how many coders and engineers have worked with and learned hex, someone else must have already done this, its too obvious)

I also find using decimal numbers verbally like one,two,three are very confusing for hex
so I designed a simple way to vocalize the binary glyphs
I(eye) is a higher frequency than A(ahh) so I make the higher frequency the higher value (entropy/redshift/low-value association is consistent with the rest of  uscript)

I also use a simple visualization technique for numbers, numbers are 4 square groups of 4 dot squares.
The "full blocks of 4 points" are separated from the "unfinished dot block" so it feels more like "14 is 3 blocks and 2 dots"
I find this quite easy to visualize and use in working memory.

Page	defs	desc	todo
Page 1	This page introduces the first step numbers and simple equations . I toss in a couple extra visual examples for arrow , time/entropy , etc DO NOT NIT PICK THEM They aren't actually 'used' or necessary' I like them because they add some general vibe to the first page But they are not actually relied on going forward if you want to complain about them then just ignore them. pretend they aren't there they are just superfluous window dressing tone setting I only do this on the first page You wont find this kind of 'fun unused dressing' after page 1 . The only thing of import on page one is numbers and basic math dims ... numbers fractions sci-note = + - * / exp root log alt exp sub() subtract ( 3 subtract 1 = 2 ) subtracts ( 1 subtracts 3 = 2 ) the dot in the subtract symbol represents the side kept / measured x / (divide-by) y x \ (divides) y dim corner points to the 'segment length to divide into' x to-the-power-of y x powers-of y dimension corner points to power x rooted-by y x roots y dims/split points at number of dimensions to fracture into x logged-by y x logs y dims corner points at dimensional length to fracture into	some intro vague conceptuals like arrow and subset, time/entropy, dimensions There are mirror versions of non-commutative operations the reverse the operation direction Operation direction is arbitrary anyways. For example in Chinese the normal way of expressing fractions is inverted. 1/3 on third is 三分之一 (3 split of-that 1), 三分之二 is 2/3, etc.. This will also help with design expressions and 'hiding brackets' later.	Add examples of inverted non-commutative operations add example of scinote left shift (only added right shifting so far) *string bin digits is all high or all low should include mark to show high/low if not clear *maybe fill in arrow triangle to add-mass to tip *sub example maybe clarify that all can be sub or any permutation *numbers(hex, bin-string,tens,fractions),+-/*,exp,root,log *maybe rotate number dots so they follow reading dir l-r t-b *maybe modify string numbers so that the digits around the radix point are inferred form position 1_._1 = 11.11 0-.-0 = 00.00 0-\_.1= 01.11 0-.-\_= 00.01 0-\(dot in line)_1 = 00.11 etc... !! not satisfied with ten and hun symbols.. maybe change them or delete them add some root braks?
Page 2	negative numbers floor mod round braks and op order (left to right. no priority based on operations type)	negative numbers, scinote usage, op sequence, int/frac/var symbols floor, mod, round, aprox equal(a rounded number) no bedmas, just left to right, except for scinote I admit bedmas helps hide brackets.. just like root and fraction symbols help hide brackets, or how the expression in a power is calculated before the power to hide brackets. Uscript doesn't use bedmas as a 'braket-hiding-tool', because that is a very human, historical, and culture specific system. admittedly the hidden brackets in roots, powers, and division are visually elegant, but that's not true for bedmas in general. Uscript sticks with sequential operations and brackets... we will find other ways to "hide brackets" (more visual and intuitive ones, akin to division, powers and roots in our current system), This will also provoke more divergence from our current systems, representation, and thinking.	could add 2d drawing style like upper exp, division stacks, root sign, etc.. not getting into that stuff now.. strictly linear bracketed for now will establish ints, rationals, and later irrationals.. probably stop there for 1d numbers to start, can use clauses to establish subsets of those when needed, or establish a symbol later on if actually necessary or needed for convenience
Page 3	true false bool ops (and/or/xor/etc..) eval evalneg invert bool in math like +/-/*/etc.. true=1 false=0	Procedural basics booleans and gates	*maybe clarify that eval mode is supplemented by gt / lt cooperators which can perform actual comparisons like > < == etc.. if they return 0 then things are equal
Page 4	int frac and var types wave/undefined/uncertain how vars work absolute absolute equal != > < gt/lt.by how much. not just bool is-greater-than. bool. regular gt can be used for bool logic already this one is better for 'making statements' is-less-than not-less-than. equivalent to >= not-greater-than. equivalent to <= Uscript "integers" are explcitily defined as dyadic rationals defined as a whole number and a radix shift integer-number integer-shift approximately equal to. specifically rounded number with overlapping ranges a approx b = abs(a-b) is-less-than (precision-a + precision-b)/2 micro/mega/nano/giga shift the radix in increments of 16 places we already have nice scinote symbols for shifting. these prevent the need for large exponent scinote . with a the 4 bit scinote symbol (the same size as our basic number digits) the range is 16 radix points so these jump us into a new range before we need to use larger symbols mega = 1 scinote+16(1*16^16) giga = 1 scinote+32(1*16^32) this gives easy number expressions to large scales Particularly important for physical units Think of it like this... we use scinote to cover a big range 0.0000 0000 0000 0000 1 -> 1 0000 0000 0000 0000 beyond that the scinote symbol gets long and powers that large are hard to comprehend so we use micro/mega/nano/giga to jump into the other ranges you can still use arbitrarily long scinote if you insist micro (hex 10^-10) mega(hex 10^10) nano(hex 10^-20) giga(hex 10^20)	introducing real numbers, fraction and variables as categories of "numbers" variables, or "wave-numbers" are like using a,b,c,...x,y,z as variables, except that that are wave-1, wave-2, wave-3, etc.. our "integers" are now clarified to dyadic rationals We will operate under the premise that: "all numbers are fundamentally a binary int plus a scinote."(basically a float) so "under the hood" there are 2 values in every number : an integer and an exponent *fraction we bee seen as "a formula, not a number" the integer number and exponent NEVER have a radix and this structure is how define "approximately equals to" if you want to do a tolerance then use tolerance. approx is a SPECIFIC thing. it means rounded to the most precise digit given Micro/Mega Nano/Giga I don't use kilo or milli because they mean 1000 nano micro mega and giga are just words They mean dwarf/small/great/giant But the name is only in the markup language these words are not part of Uscript so it doesn't really matter i guess	mega/micro/nano/giga/etc.. scale by alot scinote scales by smaller amounts they are used in conjunction and they can be blended into compound symbols clean p the int/frac categorization. maybe move fracs to later, so we can specify that "not all fracs are ints" (right now expressive tools are a bit lacking for that) add definition of mega/micro/etc.. add approx examples
Page 5	varset :> <: swap var values add right to left add left to right subtract right from left subtract left from right set left to right value. then zero the right value set right to left value. then zero the left value Move-left. add right value into left var. then zero right var Move-right. subtract left value from right var. then zero left var Remove-left. subtract right value from left var. then zero right var Remove-right. move left value into right var. then zero left var sub right from left and add left to right. Simultaneous actions. sub left from right and add right to left. Simultaneous actions. add R to L. subtract L from R twice. simultaneous L = L + R. R = R * L - L. All ops use the original var values L = L exp R divides R + R aka.L=(R/(L^R))+R.... R = R * L - L ops are 'loaded with values then pushed into the vars' so they execute 'outside inwards' if( ){ } ifn( ){ } iff( ){ } iffn( ){ }	Varset defined we only define the case of a single varset per expression, and it causes both sides to be fully evaluated before the varset weird cases are undefined for now. like multiple varsets per expression, or varsets inside of brackets. procedural intro variable setting, if conditionals, sequential operations We now have varset so we can distinguish between statements of x is equal to y and instructions of set x to be y. so we don't need to rely on bracketing and subsets to show the results of variable actions. IF evaluates the raw result of conditional IFF (if false) inverts the conditional evaluation yes, there is redundancy it is a byproduct lower level design it allows us to connect multiple outputs to a single conditional (can connect both result cases , it allows adding an else) you can also consider it as optional ways to offer different contextual emphasis if and iffn both do the same	Now that we have varset to contrast with equals, should add examples to clarify that using equals alone outside for execution is "a description/statement/explanation, not an action". it is kind of implied from this point on by the way they are used. but should probably try to establish it strongly and explicitly at this point in the flow. todo more examples of variable setters add a version of varset where there is a center braketed or bin sring. that means the the center value is applied to both sides (eg "v1 < sub : 3 : add > v2" = "sub 3 from v1 and add 3 to v2" ) add expression vars add examples where more than 2 vars are involved, a center expression that can be applied in different ways to many variable (eg value 3 can applied in different ways to many different variables with many varset arrows all originating form the same central bracket each with different operators.) *not sure if i will include that in this version but this is definitely something to flesh out later. time time time.. so much to do, so little time. might need to redefine the way operators are written into the operator line. Probably need 'top-bottom' orientation of the operator symbol to become relative to reading direction. (place your perspective inside the line at the midpoint (:) then flow to each side and treat left and right as absolute 'up/down'
Page 6	array def ([][][]...) array ref v1 s[1] ops across all elements of array sum() count() avg() prod([1][2][3]) expo([1][2][3])	arrays	Array * array = matrix matrix diagonal extraction Some of these definitions would be easier if I add array pop here first, instead of later add standard deviation brak
Page 7	nlcon connect to preceding line while ( ... ) { ... } while-false loop end op	define line connector. It allows be linked to be an extension of the previous, essentially saying ignore previous carriage return. while loop definition	while-false is not fully defined yet it will mean "execute once at the end when the loop breaks. This allows both the loop and an exit condition to be draw as a single unit it also creates a single symbol for "wait until a condition, then do this" yes you can just add code underneath a while loop. Uscript will use these in more abstract linguistic environments, so codifying these things connected units is useful
Page 8	foreach( ... ) { ... } exe( ... ) return a symbol to stand in for variable of the current iteration next loopval prev loopval loopval 2 loops ahead. 3 loops ahead. 4. 5. etc.. loopval 2 loops back. 3 loops back. 4. 5. etc. original loop vals before the loop executed original loop vals are for reference only. constant values during loop loop-counter starts at one increments after each cycle the return value which can be modified when inside the loop. setting this does not break the loop. the return is the final value after the loop finishes.	foreach and execution brak	more examples of loopvar foreach doesn't need to braket input when no "as x" is used define that when inside a loop, or anything, varset 'into-nothing' has the function of setting a return value for the loop, or if, etc.. Seeing as I added reverse pop all loops, should probably add reverse foreach loop loopvar symbols dont address nested loops, maybe give it a way to reference levels I think just allow the loopvar to be treated as an array, but make a special call were you reference an array element using sci-note eg loopvar[scinote+1] = up one nested loop level need to add example of all the extra loopvars (next,prev,original,etc..)
Page 9	array append array combine (array of arrays) ... = Condition to find single elements. first qualifying element is returned ... = Condition to find multiple elements. Qualifying elements are included in output array extract elements(s) removes them from array glyph shows bond/appended where one is extracted extract elements(s) removes them from array extract sub-array . pulls out a sub element as a standalone array new array of array[*][x] with x bumped up to parent tier	array combine array append array subset	finish updating subarray ops it was split into single result and array result needs extra defs and need to go through other pages to update old defs that are now wrong update array conditional def to reflect the new updated version the simple glyph now only extracts a single element, and the array version returns all matches define array extract multi element matches returns array id reference return only the element (not encased as an array for one element) condition extracts all that match discard the return to just 'delete' from array **add clearer examples here of appending to loop return to give an array result from a loop **could do so many more array ops, but drawing the line for now **add count/sum/avg onto array extract for quick ops(just add small icon prefix to the box protrusion). that way you can ask "how many meet this conditon" etc..
Page 10	maybe some more range one like "how much of the range it fill" or "how much the ranges overlap" has/is-in expression group these might feel redundant when we have array contains operators. We have three different way to discuss similar things set theory , array ops , and has/isin The has/is-in will be useful later when we abstract We can ovoid overloading array and set theory ops too much ... has o o is in ... ... doesn't have o o is not in ... ... has something approximately o something approximately o is in ... ... doesn't have something approximately o something approximately o is not in ... ... has something that's not o something not o is in ... ... doesn't have something that's not o something not o is not in ... the has/isin search for elements in an array. it means "array A has element B" "array A has array B" checks if an element of A IS the array B You can put comparator and formula in has/isnin braks eg. A has > 5 or A has [1] = 5 (any A[*][1] = 5) . Set theory operators compare 2 arrays to each other superset of subset of set overlap no set overlap pop first array element pop last array element tolerance rangecontains range a contains range b rangecontained range a falls inside of range b and left. L = L and R or left . L = L or R	set symbols sub/superset overlap, no overlap tolerance array pop bool varsets tolerance here means "deviation must be less than" not "deviation acceptable up to". pops will serve well as the idea of "taking from" later establish that a unilateral varset operation can be evaluated and check. its value is equal to resulting new value of the variable. bool ops can be used with varset the op using the establish patterns might need more examples, but the patter is clear i think 5 tolerance 2 include 3.0000001 but does not include 3 or 7 all/non/etc... these benefit more form expression variables which come later	define rangecontains define all the new "has/isinetc.." and make 'mini single symbol boolean comparator symbols' for them add set symbols definitions add default version that doesn't include the "equals dots" and make it default to the "equals dots version" add popping empty array and referencing non-existent array elements. add it to later pages where undefined/wave has be established **should probably add invert-array symbol(rotate-array) **add other form of tolerance deviation up to and including) **add examples of tolerance where numbers are drawn above or below to manipulate the upper and lower bounds independently Add defintion that declare "a larger number contains a smaller number" using has. this is the behavior if the checked input is not an array. this way it can be abstracted better into linguistic usage.
Page 11	expression vars hold expressions expression holding braket allpop last to first. A foreach that empties as it goes popall first to last. A foreach that empties as it goes asteps. array steps. first to last. stepsa. array steps last to first arraysteps runs for 'gap between elements' there's no current loopvar just prev and next array sort. small -> large reverse sort. large -> small acontains array a contains array b bool return. all contained or false acontained array a contained within array b bool return. all contained or false acontainscount array a contains array b count. number of matches acontainedcount array a contained within array b count. number of matches array flip. flips order forward/backwards	expression vars expression vars hold expressions, we ONLY define simple usage here we do NOT address expressions containing expressions vars, or any other complex applications Yes! introducing expression vars opens the door to a lot of questions... "how do I put the value from a variable into an expression as a fixed value instead of variable reference?" how do I build a dynamic expression then lock it down so I can now change the vars used to create it? etc.. the answer is "Those are questions for another day.. those behaviors are undefined for today" pop loops - they popall elements and handle each. There is still a 'if true dot' on the sub brak becaus ethsi way we can add a false one to run at the end. Pop loops are different from foreach loops, pop loops empty the original array, this means they can better represent situation when things are handle or processed. Many physical process of "take all of X and process them" convert or destroy the original source material.So this is actually a useful distinction for abstracting into language. array sorts simple value sorts on simple 1d arrays for now later can add bracketing and nuance to sorting	array sort example is just an example of an array unsorted and sorted. should add full algorithm description
Page 12	f1(1) f2(1 , 3) custom functions establish behavior of undefined variables in equations if one value is undefined then return the defined value unchanged if both are undefined then return an undefined value	all/any/none/any-dont those which min/max Custom function Define loop return values and how to manipulate them default return is number of loops executed. but setting it at any point overrides that behavior establish that undefined variables have no effect in equations. an undefined variable acts as 0 in additions and subtraction. as 1 in * / ^, in 'x divides y' an undefined y acts as x^2 etc.. 1.if one of the values is defined then you get the defined value as a result 2.with 2 undefiuned values the result is an undefined value. For custom functions you can use any symbol as the brac symbol. but I have only added custom alignment for number 1 to 6 I simple number might be best,. of course custom symbols can be designed and drawn. but for general purpose function definition and usage, I think just labeling them the same everything is given an ID is the simplest solution for now there now alot of what is needed for calculus we can even draw the procedural logic quite elegantly function, array pair loops can draw trapezoidal areas under iterated functions ...debating the order and sequence of how to add calculus and geometry before moving on physics and astronmy	should add more loop return behavior examples
Page 13	all - the and bool array brak Bool array braks use boolean op between all array elements all( array(a , b , c) ) = a && b && c none - uses nor between all array elements nor returns true is both are false any - uses the OR between all array elements min - returns the smallest value in the array max - returns the largest value in the array introduce array conditional bool loops easy way to discuss arrays and groups "all of x meet condition y" "non of x have element y" "at least some of x have property y" , etc.. all meet condition uses the and loop on an array conditional any meet condition uses the or loop on an array conditional none meet condition uses the nor loop on an array conditional	all/any/none/any-dont min/max establish that reg brackets don't add depth to arrays. they are only used to wrap them for assignments. double or triple wrapping them does do anything different than single wrapping.	add bit wise bool ops I have not added them yet because they don't have immediate use, but considering procedural is such a fundamental layer, and numbers are bit constructed, it feels obvious that bit-wise operators should be included in Uscript.
Page 14	pi radius diameter circumference circle circle area 2D cartesian X 2D cartesian Y 2D cart perimeter angle radian triangle tringle corners triangle sides right triangle right tri sides right tri corners sin cos tan general 2d space circle area 2d cart area triangle area right triangle area	geometry a simple thing like pi, defined by the value, using basic math expressions we can build up so much. a quick define that strings of solid symbols (like bin string numbers, variable, fractions) are multiplication by default. Things left out triangle perimeters. yes, things like herons formula can use perimeter of a triangle usefully.. but for now I'm keeping it simple and only restricting myself to the most function or fundamental. I was even reluctant to include Cartesian perimeter.	add conceppt of 'perpendicular to' and then better define axis and planes add symbol for 'other shapes/spaces'.. just define it as 'all spaces/shapes that don't fit into any of the established categories. also, add symbols for ellipses, etc... the geometry rabbit hole is deep and I don't want to loose myself in it right now. maybe take the has/hasnot/isin/isnotin ops and bring them to page-1 with visual examples?
Page 15	infinity a fused number 1 and plus symbol output is looped back into an input defined as { while(true){x+=1;} return x;} = infinity 1 / infinity apair array pairing op {1 , 2 , 3} apair {a , b , c} = { {1 , a} , {2 , b} , {3 , c} } we define its behaviour "enough for now". Enough to use it for basic calculus. X Y dx dy x1. first x in an interval x2. second x in an interval y1. first y in an interval y2. second y in an interval dx/dy. change/slope of X (vertical) from perspective of one Y (horizontal) unit dy/dx. change/slope of Y(horizontal) from perspective of one X (vertical) unit area with respect to X (under curve) area with respect to Y the array interval gap before an element the array interval gap after an element the array interval gap between two elements	infinity array pairing	Arbitrary! dont rant at me about why these choices are not universal.. they are NOT universal. right vs left = completely arbitrary up down has a bit of physical and abstract intuition. but you could easily find equally valid intuitions to argue for the opposite. should expand on the definition of 'reverse' gaps, which look at an interval backwards inverting the x1,x2 sequence and thus inverting the sign change the example so that it is offset from origin (like just a +1) so that way the xarea and y area are different in the examples
Page 16	array generator. first value to last value center op value is number of intervals 1 agen(1) 3 = {1 , 3} 1 agen(2) 3 = {1 , 2 , 3} a agen(x) b = { (b-a)*1/x , (b-a)*2/x , etc... b } point slope (dy/dx lim inf) inverted point slope (dx/dy lim inf) trapezoidal integration with respect to X trapezoidal integration with respect to Y xint braket integrate f1(x) on x from v1 to v2 defined as trapezoidal integration with infinite resolution yint braket integrate f1(x) on y from v1 to v2	Successfully defined basic calculus without resorting to drawing pictographic graphs as example. Used some visual elements in the symbols, but the symbols are defined by explicitly defined processes, formulas, and examples here build an array generator the array generator can generate an array of bounded input values those values can be paired to a function and used for Riemann sums and stuff. I will focus on trapezoidal integration so that we don't start inferring data beyond the range bounding points	will add more notation formats. eg rotating the integration notation vertically. also design in implied nesting, as opposed to requiring explicit bracketing, will need to use spacial layout to imply bracketing, like standard notation systems. but this is enough for function any current needs. doubt ill even need multidimensional calculus at the moment. can nest, and there are way to represent anything you need, just might be a bit bulky without some implied bracketing optimizations. What is here seem like a reasonable place to move on for now. Later come back and flesh it out more. Clearly need to touch up the number string generator. keeps adding 4 bits for zero before radix
Page 17	mass. just a symbol in the chart of numbers can be seen as arbitrary for now but it is a combination of "interaction" and "spacetime" both those radicals are not yet defined so for now its just an arbitrary symbol . we give electron a unit of nano so that nano->giga + scinote can easily cover the full range of scales we should ever need proton neutron electron muon tau electron neutrino muon neutrino tau neutrino up quark charm quark top quark down quark strange quark bottom quark photon gluon wboson zboson higgs fermion lepton quark boson gauge boson . anti particles are just vertically inverted symbols . elec muon tau anti elec muon tau elec muon tau neutrinos anti elec muon tau neutrinos up charm top quark anti up charm top quark down strange bot anti down strange bot w boson anti w boson anti fermion fermion gauge boson anti gauge boson lepton anti lepton quark antiquark	particles are defined by a chart of masses mass units are not universal... ... But the ratios are electron, muon, tau, proton, neutron, and W/Z boson can alone create a chart with more than enough precision to be a universal starting point a muon is 206.7... electrons in mass* So the chart as a whole is universal *many particles have some tolerances on mass certainty. electron mass is known to high order of precision and the mass units used IS electrons, everything is stated in terms of 'this ≈ x electrons of mass'. particle symbols are composed of uscript radicals The symbol design tries to be representative but the definition is the mass chart Don't confuse an attempt to make the symbol descriptive . . . with the actual definition . . . See this page for the chart Leptons are wave radical combined with dot or circle dot : true .. particle .. charge circle : zero .. space .. false .. no charge so charge leptons use a dot and neutral leptons use a circle. more wave zig-zags imply 'more'(mass) Quarks use a triangle combine with particle The triangle shapes is used for color charge representations The number of particles on the triangle represents charge thirds photon is a particle inside a wave. both because a photon is more wave than particle (compared to other particles) and because antiparticles are made by flipping the particle symbol upside-down, and this way the photon doesn't change, 'because a photon is it own antiparticle' gluon are 2 triangles connect by a wave, representing color charge interaction. the 2 triangles can be used to make color charges ( done with lines in the corners) W and Z bosons. W boson is charge so it has a dot, Z boson neutral so it has a circle. Their most iconic interactions involve quarks, so a triangle is used. (Yes, they also interact with leptons, bur remember, these symbols are just symbols only try to representative, the definition is the mass chart and later formulas/expressions) higgs uses a later defined symbol of 'spacetime' + wave(interaction) + circle(neutral) Within the defintion of symbols dots mean charge and circles mean neutral But outside of particles those symbols have broader scopes. Dot can me particle in general, or true, whole unit, etc.. Circle can be space, area, zero, empty, etc.. antiparticles are just described as '-' or 'invert' of a particle. This is NOT a full proper definition of antiparticles I just split it into the next page because this page info/ description is getting big due to the "massive symbol dump" of particles.
Page 18	charge the electron is the uscript unit particle. mass and charge giving it a negative charge was kind of 'historical mistake' . physical manifestations of electric discharge are asymmetric and characterize by directional flow of electrons. electrons are more mobile than protons so 'they are the fluid/movers' When you see electric discharge. It's almost always electrons flowing . So uscript charge is 'inverted' compared to earths 'backwards legacy'. I added 'negtron' as a synonym for 'proton' to help me with this. I find 'proton' mnemonically triggers 'positive' for me spin yes. it was proposed to be physical 3d spin because it produces orientation in 3d space it was NOT that but weirdly it is still a value used in equations of rotation it was called spin incorrectly but turned out be a different kind of 'spin quality'. funny huh. . added sub-types of quarks and leptons Did this to create good example of taxonomy up typequark down type quark charged lepton neutrino . here the ambiguous sub() gets important sub-types the unspecified subcup() is ambiguous . these new 4 are explicit taxonomy vs. composition vs. condition vs. property conditional is done with procedural particles have "composite objects" and "categories" so now its easy to distinguish these ideas radicals use for these new sub types are not fully defined yet. but thats not necesarry. plus these use cases help establish their lexical scope. "hierarchical" radical for taxonomy "system" radical with "system particle" selected for composition "conditional" uses the sub component of the procedural "IF bracket" "property" uses "interaction" radical (how something interacts) . This is just first introduction they will become more clearly defined going forward atoms/molecules/etc will all help clarify these defintions is-sub-of is-parent-of ambiguous 'sub' is-cat-of is-type-of subcat is-made-of is-part-of subpart implies implied-by subif has-property is-property-of subprop	introduce more properties like charge and spin add some refinements to array descriptive and handling tools instead of just listing the properties of each particle, we will take this opportunity to start "talking about things". using some of the tools for arrays we can say things like "all quarks have mass greater than 1" to do this we use "quark array-condition-all[mass > 1] = true" which is a structure already defined to translate into procedural code "{ foreach(quark) { last-result && (this-quark[mass] > 1); } return chained result; } Also, and more importantly the sub-[ expression has been as an ambiguous hierarchy symbol. x subcup(y) means many things "y is a category of x" "y is a component of x" "y is true under x conditions" We need to start explicitification(yes, that's, I was as surprised as you, it feels made up) now that we have physical things composed of each other, and categories to group them into, plus procedural for conditions, we can now create differentiated version of the sub() structure we will keep the ambiguous version. it can be handy. so subcup() has 4 subtypes now conditional (implies/causes) taxonomical (subtype of) mereological (composition of) qualitative (properties of) taxonomy : "x subcat(y)", y is astronomically under x. doesnt matter how many layers, because you could always introduce new arbitrary category layers. as for : asking "how many layers down?", is directly under/above?" "etc, these questions are for another day.	clarify that some symbols violate "linear operation sequence" inv(-) or property name like charge/mass etc.. are prefix to a value, so they essentially create a bracket. this should be clarified explicitly
Page 19	general atom symbol drawn by the word 'atom' atom(1) hydrogen atom(2) helium atom(3) lithium yes. the number strokes lines are very thin. right now it is just scaling the number vector. It will need to be redone with a thicker line width later IONS atom(1.1) hydrogen +1 electron anion atom(6.-1) carbon -1 electron cation ISOTOPES atom(6 14) carbon 14 atom(8 17)oxygen 17 atom(1 +1) hydrogen +1 neutron isotope. atom(7 -2) nitrogen -2 neutron isotope. 7 proton 5 secondary notation method. the adjuster number specifies 'neutron count = proton_count +/- x' atom (82 208) = atom (82 +44) Lead 208 (neutrons = protons + 44) might add third isotope notation based on beta-stability line deviation ISOTOPES + IONS don't use the '.' for the ion. just space it out as the third value atom (1 1 -1) hydrogen-1 -1 electron. aka a proton atom (8 16 2) oxygen-16 +2 electrons atom (8 +1 1) oxygen-17 +1 electrons language style expression start coming together some simplified sentence strictures start getting defined "atom is-made-of 2 proton implies helium" . remember , these markup words are not literal These English words are just approximations for the markup language the definitions are in uscript , not English! is-made-of does not reference English terms it is just a markup version of a uscript self-defined term . The grammar structures defined in this page are some simple simplifications this sentence simplifies from "(atom subpart(proton proton)) if-that-is-true(atom = helium ) item vars. var symbol with 'particle' prefix. a var that references a 'thing' could easily just use 'normal vars to talk about things too but always better for the var symbol to show what kind of value it's holding This is going to ba a pattern. many types of 'vars' it's a fun alternative style to explore imagine that Chinese characters were the only language , what would programming look like? how would you name and handle variables if you don't name them with strings of letters? At first we moved stuff around in numeric memory banks/registers/etc.. but we quickly needed work with too many variables named variables named structures and named classes and named objects etc.. All those development frameworks were based on alphabetical language What if there wasn't an alphabet? as a programmer fluent in English and Chinese I can confidently say: The current systems are optimized for alphabetical language it is unlikely that it would be just a 'font swap' Character languages don't fit as neatly into this paradigm What would if happen if something like Chinese characters was the only language? I don't know fully know where Uscript will lead me But I'm going to have fun going down this non-phonetic script path I have not designed it yet. going to follow the flow But I am pretty sure its going to rely far more heavily on structures/objects/classes and ability to do contextual redefinition of symbols within structures	temp place holder page	third isotope notation?