Agree (no checkbox) to the opensource license at bottom of this file or dont use this.
Wikibinator203, a programming language where everything is made of a universal function called on itself in many combos. This is an early experiment and will be easier to play with when it has voxel graphics and is a massively-multiplayer compute cloud. Imagine millions of people doing this in an infinite dimensional turing-complete space, but not able to get in eachothers way since the directed-graph you see below, of working javascript lambdas (try them on browser console or here) is immutable/stateless, a lazy-evaled merkle-forest. Scroll down for some example code to copy/paste into IN textarea below.

λ means Lambda. (λ [a b c] [comment] T) and node.prototype.p(name)
(P a (λ [a b c] [comment] T Pair)) -> Pair
(P a (λ [a b c] [comment] T Pair S)) -> Pair
(P b (λ [a b c] [comment] T Pair S)) -> S
(λ [a b c] [comment] (P a) Pair S L) -> Pair
(λ [a b c] [comment] (P b) Pair S L) -> S
(λ [a b c] [comment] (P c) Pair S L) -> L
(λ [a b c d] [a prefix then reverses 4 params] {(T []) (T backward ) (T is) (P d) (P c) (P b) (P a)} these are some words) --> [backward is words some are these]

TODO: [ (=m ob key val) //Mut.valMap[Mut]->Mut. ob, key, and val must all be deduped. Both js {} and js [] go here. (=f ob fn) //ob deduped, fn may be dup. (=n ob num) //ob deduped, num probably deduped cuz numbers are so small it happens automatically, but not technically required. Maybe this should be raw 64 bits, implying double. (=b ob typedblob) //ob deduped, typedblob may be dup. typedblob may be Uint8Array, Float32Array, etc. ]

TODO Changing the syntax of vm.eval(codeString)->lambda. Theres 4 s-expression-like things: {a b} is normal call. {a b c} is {{a b} c}. (this is (just data) put anything {a b} here). () is an empty such list. is {S a b}. is {S {S a b} c}. [a b c] is <,a b c>. ,a is {T a}


Test Wikibinator203 prototype (incomplete but works a little)
Wikibinator203 code in. It evals while you type,
but until vm.stackTime and vm.stackMem are working,
you might have to close and reopen browser tab if you write an infinite loop). Example: (Pair (F U) S F) -> S
Example: [(APair#(Pair こんに ちは世界) F) (APair T)]
Example: [the first half is (Typeval U (L (R Abc#こんにちは世界))) and the second half is (Typeval U (R (R Abc))) but that seems to have a problem with the padding]
Example: (Pair (F U) S T) -> (F U)
Example: Pair -> Pair
Example: ([L R L R] Pair Pair L S R) -> [L R L R Pair Pair L S R]
Example: (L ([L R L R] Pair Pair L S R)) -> [L R L R Pair Pair L S]
Example: (R ([L R L R] Pair Pair L S R)) -> R
Example: (L U (R U)) -> U
Example: (L L (R L)) -> L
Example: (L R (R R)) -> R
Example: (L S (R S)) -> S
Example: (L (Pair S T) (R (Pair S T))) -> (Pair S T) - aka (Pair S T) is the iota lambda
Example: ((Pair S T) (Pair S T) [L R L R S]) -> [L R L R S] - cuz iota called on itself is an identityFunc.
Example: ((Pair S T) (Pair S T) (Pair S T)) -> (Pair S T) - cuz iota called on itself is an identityFunc.
Example: ((Pair S T) ((Pair S T) ((Pair S T) (Pair S T)))) -> T
- as in cuz T is the K of SKI-Calculus.
Example: ((Pair S T) ((Pair S T) ((Pair S T) ((Pair S T) (Pair S T))))) -> S
- as in cuz T is the K of SKI-Calculus.
This is an infinite loop (though runs out of javascript stack: (S (F U) (F U) (S (F U) (F U)))
It will be much easier use when Names#(...) and drag-and-drop and 1024x1024 per pixel graphics are working.

TODO, M[...] syntax aka (M [...]) where a lack of whitespace between 2 things means call one on the other, and : between them will do the same thing.

TODO, something I'll build to improve the UI later... Right click any node to edit it as a string of code, in its dom node (dob), which as you type creates/finds new nodes below it (or only if you push a certain button since that might be confusing to have stuff change so fast), and while editing you can choose a subset of the nodes on screen that can reach it by l and r edges (easiest way is edit nodeA as viewed from nodeB which can reach nodeA, and a button to save a snapshot of it into the nodes directed graph), and that subset can be copied then modified or just modified, and such modifying/editing does not affect the 256 bit ids (TODO ids) of the nodes, just is different lambdas.

LICENSE AT TIME 2022-8-3 IS THIS BUT TODO COPY CHANGED LICENSE (BEFORE FINALIZING IT SOMEDAY) FROM LICENSE FILE WHEN CHANGED:[[[ Ben F Rayfield offers the wikibinator203 VM prototype, UI, and various tools, under this license

I (Ben F Rayfield) know this license is a mess and am planning to rewrite it to be much smaller, divided into small paragraphs, move some parts to tutorials or other documents about the software, and only keep the parts that arent strongly implied by the other parts. Now that I've written about the "infinite size unweighted directed-graph with 3 edge-colors", that seems an easier way to explain why it would cause problems for specific people to own specific nodes and edges in that directed-graph, and that nodes could be dangerous if copied into executable files outside the system, etc.

This license contains the 3 paragraphs of the MIT license and some extra copyleft stuff.

This is experimental software.


This software uses a constant infinite size unweighted directed-graph with 3 edge-colors, that contains all possible patterns of finite amount of information that take finite amount of compute time and memory, which an infinite number of subsets of it (if not the whole thing?) are already near optimally compressed (near lowest kolmogorov complexity) in its natural form. These edges are Func, Param, and EvalsTo, where Func called on Param returns EvalsTo. Nobody owns that directed-graph nor any nodes or edges in it, nor the using of it as lambdas/wikibs (nodes are lambdas/wikibs). Nobody owns wikibs. They are shared facts of maths many people and software can use together. A wikib is a kind of number, stateless and immutable (or approximations of it in some ways of using it) universal lambda function, combinator, pattern-calculus function, fact of math, a pure function, and a data structure that is defined completely as a forest node with 2 child wikibs down to leaf (leaf also has 2 childs (identity function and leaf)). Leaf (aka U aka Wikibinator203) is the universal function, from which all turing-complete patterns of finite amount of information can be built, used, and shared. Forall wikib x, forall wikib y, x called on y is a wikib, which may be halted or evaling (to a halted wikib or never halts). Every wikib is a derivative-work of leaf, which can be proven by calling leaf on itself in various combinations, to make any wikib. While obeying this license and using a wikibinator203 VM that correctly implements the spec, it is safe to call any wikib on any wikib since all it does is find or create wikibs, but if its used to control external systems (such as robots, buying and selling things, or telling people what to believe or what to do outside a simulated world, or copying a wikib to a new file, renaming that file x.exe, then double-clicking that file), it is entirely the responsibility of who hooks it to those systems to verify its safe, such as by math proofs, networks of digital signatures, or other evidence, especially considering that it can create all possible computer viruses and ransomware and other evil things (safely in a sandbox across 1 or many computers) and good things, and that in 1 of its 2 namespaces (evilbit=true), it is an antivirus quarantine and uncensored area, a sandbox across whichever computers opt into using this data structure together, where all possible wikibs are allowed. In the antivirus quarantine, you may share viruses like posts in a social network, turing-complete messages that others may, for example, say ["this is a virus" TheVirus] or use the virus in a meme-like piece of art (such as a satirical work making fun of viruses could literally contain such viruses) and do experiments, make games, musical instruments, tools, or anything of pure information. It would be very destructive to the system if there is any possible math statement which is not allowed, such as removing a virus or other "evil" wikibs while it has incoming pointers. It would be destructive to the wikib systems, because halting-oracles have been proven impossible, and a halting-oracle would be needed to determine if a certain wikib would generate, or would not generate, a certain other wikib, without waiting up to an infinite time to observe what it does (by the universal lambda math). The other namespace (evilbit=false) works like the normal internet, if those who opt in can find a way to do that without breaking the wikib math so much its unusable, a way to claim a certain wikib is safe, unlike in evilbit=true where there is no reasonable expectation that it is safe to give those wikibs execute permission, or to believe any information in them, or to obey anything they might tell you to do with a message on the screen. It would be negligence for someone to give execute permission to, believe, or obey, anything in an antivirus quarantine (which many apps may run inside across many computers) if that causes a problem, and similarly for the evilbit=false area, since saying its evilbit=true or evilbit=false (which happens in the first byte of a 256 bit id for example) is just a word that people or computers can say about a wikib, that they believe it to be safe or not. If in doubt, use evilbit=true aka antivirus quarantine. The 256 (or 512) bit ids can safely be shared in public as #hashtags. The sending and receiving of this data structure across a network does not count that network as an "external system" and is part of the sandbox. Similarly, a Human just using the facts of math together with other Humans and AIs, is part of the sandbox, as a wikib can exist inside a Human mind (which is turing-complete), but believing or obeying it in the Human mind is outside the sandbox. A wikib being a "fact of math" is inside the sandbox, and can derive its own ids which are similar to godel-numbers, and in the pure deterministic (not "approximations") way of using it, it can not lie about anything inside the sandbox, but if its viewed as statements about outside the sandbox those can be lies. For example, the wikib "this sentence is false", and "two plus two equals five", are both true, since those are just utf8 bytes, and it is true that they do not break any rules of the universal lambda, but if you view them as statements about natural-language then that refers to patterns of thoughts outside the sandbox. If instead you derive numbers and use the Ax opcode to prove a function called on a param gives a certain return value, then it will not halt if you try to eval either of those in pure math form. All halted wikibs are true. All wikibs which will never halt are false. Approximations of wikibs can guarantee halting by recursively limiting compute time and memory etc, so in theory there should be some way to safely use it to operate time critical dangerous processes in the evilbit=true area, but due to the evilbit=false area "throwing a wrench into the machine" by removing pieces of math based on Human opinions etc, the antivirus quarantine is safest. The antivirus quarantine, in the way its the math that the code is based on, has already whitelisted an infinite set, (of all of a certain kind of universal function, by calling it on itself in various combos) unlike the common practice of blacklisting "evil" things as they are observed or predicted over time. The only thing the antivirus quarantine blacklists is mutable state. A pure function can not infect a harddrive or RAM etc, since it can not call thePureFunction(mutableState)->next_mutableState, except to store cached function calls (including wrapping tiny and bigdata size bitstrings). A virus is only dangerous if it can modify some mutable state. This is a formal-verification system. This is also a low-latency number-crunching turing-complete system. For example, this system's turing-complete-type-system can have a linked-list of lambdas that when called on [church-pair of themself and themself] evals to one of the representations of the exact value of pi, and if you tried to insert into that linked-list a value not matching that, it would never halt, and if you tried to insert, in parallel a million values matching that, you would in each of those million wikib_called_on_wikib get a linked-list with 1 more thing in it.

If there is any conflict between the above "Nobody owns wikibs" paragraph and the below 2 paragraphs copied from MIT license, then that "Nobody owns wikibs" paragraph wins, overpowers the legal effects, of the 2 paragraphs below, and if that is not legally possible to do then it is not legally possible to use this software at all.

Except for the "Nobody owns wikibs" paragraph above, which in a copyleft way applies to every wikibinator203 VM, permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. ]]]