?ProjectLunaRed (non community project)DynamicLand (non community project)Unison (non community project)Cranq (formerly flowCODE)
Appshare (formerly Yazz Pilot)
JaiMuValOS (Valaa Open System)InstadeqLamduGlanceCurvWaspHestTree NotationOnex/Object NetworkKayiaSubtextInfusionUltorg (formerly SIEUFERD)ParasailLobsterLESHilltopBeadsMaracaDarkMechLynxtoolCeptreEveRestructorAardappel
Primary dev(s)Wojciech Daniło, Marcin KostrzewaNenad RakocevicBret VictorDan StockerZubair QuraishiJonathan BlowKartik AgaramIridian Kiiskinen, Ville Ilkkala, Ilari KajasteMariano Guerra, Javier Dall' AmoreEyal Lotem, Yair ChuchemRobbie Gleichman, Daniel GarciaDoug MoenMartin Sosic, Matija SosicIvan ReeseBreck YunitsDuncan CraggDavid BroderickJonathan EdwardsAntranig Basman/Fluid ProjectEirik BakkeTucker TaftWouter van OortmerssenDavid PiepgrassDan SwirskyEdward de JongJon WhiteheadPaul Biggar, Ellen ChisaCorey MontellaTim BabbChris MartensChris Granger, Rob Attorri, Josh Cole, Corey Montella, Wouter van OortmerssenWouter van Oortmerssen
Unique Selling Proposition (or your elevator pitch!)Luna is a data processing and visualization environment built on a principle that people need an immediate connection to what they are building. It provides an ever-growing library of highly tailored, domain specific components and an extensible framework for building new ones.A language with two levels, one for system programming, and one for general purpose programming. The system language is custom built to allow smart contracts in cryptocurrency, the general purpose language builds on the long history of Rebol, with fresh improvements, and a much wider platform span. Red is a very powerful and compact language.Programming made tangible (edj best guess)Code is stored not as text, but in AST form, and each unique AST is given a hash so it becomes immutable.Visual programming language and development platform.

Reduces cross-organization communication overhead related to code, and boosts productivity by shortening path between intent and implementation.
An experiment to see if an Enterprise App Store can be made in Javascript, the world's worst language.

Yazz Pilot is definitely the Dogecoin of FutureOfProgramming! :)
0 Code Data Analysis and VisualizationAn experiment in creating a visual programming environment that's both powerful and easy to learn.A language for live coding of procedurally generated art. 2D, 3D, simple interactive animations. Full colour 3D printing. Text based now, visual programming in the future.Declarative language for building full-stack web apps faster and with less code. Frontend, backend and deployment - all in one concise DSL.A drawing tool with visual programming features. Execution happens in time and space, and the programmer-artist actively participates in execution.Tree Notation supports all of the semantic structures in programming—scalars, strings, lists, sets, maps, trees, scopes, expressions, statements, etc—without any syntax characters. It's a very dumb notation that simply splits a document into cells and nodes with scopes, using only spaces, newlines, and indentation.Normal people can build and share dynamic digital stuff through a peer-to-peer/decentralised architecture and animate it with accessible declarative programming.The missing link between spreadsheets and programming languages. Visual and tangible like a spreadsheet, general purpose like a programming language.
Ultorg is a graphical user interface for relational databases. By directly manipulating query results on the screen, users can construct and modify database queries at a level of expressivensess equivalent to SQL-92.A language that makes loops automatically parallel. By the author of one of the leading ADA compilers.The friendlyness of Python at the speed of Rust? Bringing advanced type and lifetime inference to the masses. Initially targetting game development.People have learned to avoid custom text formats for data, since we've standardized on JSON and XML. Code is data too, yet every new programming language has its own incompatible notation & syntax tree. LES (stored in memory as Loyc trees) is the first step toward fixing this. It's a flexible C-like language for building DSLs, with a parser simpler than C.High readability, low complexity. Flappy Bird in 91 lines with < 3 code elements per line on average.Bugs are easy to fix because the system can run backwards as well as forwards. A language so concise and mathematically symmetrical that your specification becomes executable, Progams are reliable and transfer of code bases to new staff is a breeze because programs are comprehendable. Dark is a holistic programming language, structured editor, and infrastructure, for building backend web services. It's for frontend, backend, and mobile engineers.Mech is a language for developing data-driven, reactive systems like animations, games, and robots. It makes composing, transforming, and distributing data easy, allowing you to focus on the essential complexity of your work.Pure functional programming with node+wire; using well-tested UI elements from visual effects software, plus advancements. Marketplace of code where users can share (or sell) their work.Ceptre is a rule-based programming language based on a fragment of linear logic (roughly equivalent to multiset rewriting). It has a flexible user-defined type language and is designed to permit rapid prototyping of rule systems, such as game mechanics.Structured programming with fully automatic whole program code refactoringGraphical Concurrent Tree Rewriting: Program by example visual programming with concurrent/distributed computing.
Active/Dormant/ArchivedActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActive (struggling for time)ActiveActiveActiveActiveActiveActiveActiveArchivedArchivedArchived
Web editor prototype:
Github URL
Private repositories, see website for
Twitter URL (main one for you or project)
Open or commercial or mixmixapparently neither open nor closed: people can visit but there's no public repo; it's a non-profit, but..openmixOpen source, MIT licensewill be open sourceopen; forks encouragedopen core (with potential for commercial plugins)commercialopenFree softwareopen source (Apache 2)Open source (with plans to build additional commercial products on top)Commercialopencore open, may commercialise i/o, adaptors, devices, content..commercialResearch prototypeopenCommercialopenopenopenopenmixopenmixopencommercialopenopenopenopen
If commercial, name of companyRed Foundation, et al.non-profitUnison computing, public benefit corp.Cranq LtdPrivately fundedThekla IncValaa Technologies Ltd.gnandooLunchBox SessionsOnex Software Ltd, but not commercialised yetKayiaindividualindividualUltorg LLCAdaCore sponsoredindividualindividualindividualindividualDark IncindividualVC funded (2.3 million from Andreesen/Horowitz)individualindividual
Team size
(plz order project cols by this!)
8~7anyone know ?74 part timers doing it for fun433322221 (plus 5 artists)1 full time111111111111 (project shrunk in july 2020)111411
Year project codebase started
(then order project cols by this!)
20182015201620192013201420142017Last version started in July 2019
2012201520162019research started 2013-ish
prototyping started 2015
production started 2019
2012Settled on state rewriting model in 1985
Added distributed state updates in 1992
Implemented multiple times in many languages
Nearest to current form gestated 2002..2009
199720052008Since 2008 (commercial since 2016)2009201120122014long gestation20172018201820192014201620152016
CountriesPolandChina, Europe, US, SerbiaUSUK, HungaryDistributedUSAUSASuomi (aka Finland)Argentina, Portugal, GermanyIsraelUSA, remoteCanadaCroatiaCanadaUSA, IndiaUKUSAUSAUSAUSAUSACanadaIsraelUSAUKUSAUSUSAUSUSAUSAUK
Most unusual feature(s)Bidirectional graphical and textual programming. You can change the graphics and it will update the code, or change the code and it will update the graphics. A very concise notation, with great combining power. Special attention is paid to producing Crypto contractsYou work with paper on tables animated via projectors on the ceiling, that have cameras reading dots on the page which form a barcode identifying the code.Compiles to multiple languages
Hierarchical graph
Forced focus on single component & its 1st-degree children
Global, indexed component repository
Strong emphasis on user experience
Emailable apps: All apps have a built in SQLite database with a Rails like migration schema. All apps can be saved as HTML, which saves the SQlite database schema, AND the data. That single HTML file can be emailed around which means emailable appssuper high performance at execution timeBootstraps from machine code.
Has an ugly, verbose syntax.
To minimize machine code written, optimizes for good error messages rather than clean syntax.
Code is designed to be run interactively rather than passively read.
No loops, no text entry, formula calculator, everything is draggable.Shape programs are compiled into GPU shader code for fast preview, animation and interaction.Generates nice code in web tech stack of your choice (currently only React, Redux, Node, Mongo). Allows extending via existing web technologies (js, html, css, ...). Not a general programming language (for now).Rich drawing features that the programming model emerges from. You see data flowing through your system like balls in a Rube Goldberg machine. Debug the running program by pausing, rewinding, and moving in slow motion.There are no syntax characters -- no parens, no brackets, no quotation marks, etc.There is no concept of an "application", it's more like a global cyberspace or metaverse. Each object is autonomous. Objects communicate through state updates.Works with data as an object model. Code is not stored in text files but as data, and you work with it directly in AST form.WYSIWYG semantics: code is not a dead text fed into a black box; code is live executing data structures that are fully visible. No need for a debugger. Supports Programming by Demonstration.A single visual representation shows the structure of the current database query overlaid on its own result. To achieve this, the data model of results are extended beyond the flat tabular model of SQL, to the so-called nested relational data model.automatic parallelization of codeCan infer static types and compile time memory management without the help of the programmer, goes further in this aspect than existing such languages.LES v2 is backward-compatible with JSON. LES has no semantics, but a universal Lisp-style macro system called LeMP (Lexical Macro Processor) is built on it. Enhanced C# is an example of a programming language built upon Loyc trees (same data structure as LES) and LeMP.Every value-associated element has a built-in event handler that is triggered when the value changesA replacement for Javascript, Java, and Swift. Generate web apps, mobile apps, and desktop software from a single code base. Uses deduction to dramatically reduce the amount of code that needs to be written.Compiles to native machine code. "Pure" visual language; no grammars in the interface or implementation. Heavy emphasis on design simplicity and domain agnosticism (providing small, simple, and complete set of generic primitives).linear logic programming and stagesAutomatically introduces (and removes) functions to improve the quality of code (DRY abstraction). Visual environment with type and structured error feedback.Visual/Graphical programming language based on tree rewriting (by example). Can elegantly do state & concurrency.
It's a programming languageyesyesRealtalkyesMore like a markup language for dataflow graphsNo, it just uses plain Javascript yes; a greatly cleaned up C++Muyes; extends JS with a transparent ORM to global object spaceyesyesIt's a visual programming language for a subset of Haskellyesyesyesit's a syntax. you can build programming languages on top of it we call "tree languages"yes (Onex)yesyesno, is a JS framework, but in a sense - aims to disintermediate languagesnoyesyesNo, it's a foundation for building programming languages (and DSLs, build systems, etc.)yesyesyesyesyesyesyesyesyesyes
It's an IDEyesnokinda!yesyesnoMuincludes an IDEyesyesyesyesnoyesnoyesyesyeseventuallyyesnononoyesnonoyesyesyesnoyesyesyes
It's an OSnonosorta!nonoIt has a scheduler and a process model. It runs multiple child NodeJS processes so that simple rogue processes do not bring the system downnoMuno (wrt hardware), debatably yes (wrt applications)nononononononoyeseventuallyeventuallyin a loose sense, will have "drivers" etc.nonononononononoyes (see
Live programmingyesyesyesyesyessuperfast compilernoyesyesyeshopefullyyesyestree languages can supportyesyesyesyesyesinstant startupnononot yetyesyesyesnoyesnono
Declarative or Imperativevisual direct manipulation language, bidirectional with textimperative, kinda like LISP without parenthesesmixed?mixImperativeimperativeImperativeboth? scripts are imperative, ui is declarativedeclarativedeclarative with support for imperativefunctionalimperative style programming in a pure functional languagedeclarativeit dependstree languages can be anyDeclarativedeclarativeyesdeclarativedeclarativeimperative, automatic parallelizationimperative, functional, oo, in that ordereither/bothdeclarative with some imperativecombines declarative, imperative, deductive, and constraint-based featuresvisual direct manipulation + code snippetsdeclarative, mostlyfunctionaldeclarativedeclarativemostly functionalmostly functional
"State first" or "State last"?

Do you treat state as a first class element that people see first when using your system - like Excel and Airtable do - or do you aim to hide it like OO and FP do, in their different ways?
State lastState lastState lastState firstExpressions are referentially transparent. No objects, values are immutable. But there are mutable local variables, assignments, a while statement, to support imperative programming style.extremely state firsttree languages can be anyState firstState firstState and code are coequal in dev mode. State-only in user mode.State firststate firststate firsteither/bothState firstState firstState firststate-firststate laststate last
static, strictly, dynamically typed, untypedbased on Haskelldynamicstatic, strictlyUntyped mostly, except for Custom Components which use typing for type hints in the editorstatic, strictlyMudynamicdynamically typedstaticstaticdynamic. 6 primitive types. No user defined types (they aren't needed, just as Self doesn't need classes). Statically typed subset compiles into efficient GPU shader code.dynamic-ishtree languages can be anytypes are syntax, "in the eye of the beholder"dynamicstaticuntyped, will have "type goggles"staticstatic, inferred + flow sensitive specializationanystaticstatic, strongly typed with an escape hatchstatic, strictlyuntypedhindley-milnerstrictly typeduntypedstatic, inferreddynamically typed
Pure functional in whole or in partyesnoin partnononopureyespurepure functionalin flagrantetree languages can be anyPure functional in part: uses tree/graph rewriting so doesn't have a higher level concept of "function".noPure functional looking in,
imperative looking out.
functional at the leaves, stateful at the corepureimpure (has e.g. very powerful higher order function features)anyin parthyperfunctional (code compiles to a thicket of composed calls, 2 function calls per line avg)almostnopurenonoimpureimpure
Based on logic programmingnonononononononononoyou can build logic tree languagesnoyesnonounsure (perhaps in the same sense as SQL is based on first-order logic)used to have backtracking, was removedN/Akindanoseminoyesyesnono
Elements of constraint programmingnonoIn development so that methods can be found based on example inputs and outputsnonot yetnononoyesyou can build constraint tree languagesnoyesnosome, via "lenses to self"nonoN/Ayes, lots of constraint language usednoyesnonoyesnono
Based on FRPyesnonofundamentally, but hiddenit's reactive and functionalnonoeasy-to-use mix of FRP and Elm Architectureyesyou can build frp tree languagesnononovery looselyunsure (not sure of the definition of FRP; Ultorg is reactive and functional, and permits set operations, but does not expose an explicit "map" type, for instance)used to, removedN/Aif spreadsheets are FRP, then yes (mostly), but with Eve-like code blocks instead of cellshas event model in the languagea littlenononono
Based on Object Oriented Paradigm?based on REBOLnoyes, Visual basic 6noyesyesnononoyesyou can build oo tree languagesnonononovery much optionallyN/Anocomplete opposite of OOP, no NEW or DISPOSE in languagenononononono
Homoiconic (code and data look the same; self-modifying code)yes, you can also create domain specific languages easily.nononoyou can modify the code after the parsing pass, compiler gives you full ability to modify the code via an innovative feedback into the parser.noin essence; source code Media's are first class resources of the data modelno code representation, "code" is the visual representationHopefully will support self-modificationnonoyesyesyesyesnot in terms of syntax as in LISP; yes in terms of semanticssignificantlynonoyesnono self-modifying code, but you do have a fancy preprocessor with aliasing, shortcuts, compile time IF, etc.noyesnot currently, but likely at some point.noyesnokinda, functions and data structures rewritten using same graphical rules
Target audience skill level: beginners/intermediate/advancedall rangesintermediatebeginnerall rangesVisual Basic 6 crowdintended for 3D game developmentintermediateall rangesall rangesall rangesalltech-savvy artists & 3D printer enthusiastsbeginner and intermediate web developersartistsallall rangesallbeginnersintermediateintermediateintermediateintermediate - advancedallall rangesall rangesintermediateadvancedall rangesearly: non-coders. late: everyone, coders included.allall rangesall rangesbeginner - intermediate
user engagement"mostly enable easy adoption" and "empower users""mostly enable easy adoption" and "empower users"give user a tactile method of interacting with the computer"mostly enable easy adoption" and "empower users"This is just a toy language, a fun enterprise Dev experiment some people have used to build throwaway API front ends"mostly enable easy adoption" and "empower users""mostly enable easy adoption" and "empower users". tiered APIs from easy to powerful.Empower expert userstree languages can target complete non-programmers (even with pen and paper) or the most power users on the planetquickly empower normal peopleeasy adoptioneasy adoption by casual users"mostly enable easy adoption" and "empower users"easy adoption (by any frequent Excel user)a more solid Python-like experiencewhat is this row for?easy adoptiongoal is to improve productivity of programming by a factor of 10, by eliminating most of the common errors, and ensuring all bugs are repeatableeasy adoptionprogram without having to think about abstraction: copy & paste your code and let the IDE refactor ittries to be beginner friendly by replacing variables by examples, and being graphical
language programmed inprobably HaskellTypeScript, CranqLang2013 - 2016, Clojure.

2016 - present, Javascript
C++C++ for OS and a tiny bootstrap of userland; then self-hosted. Can build itself without C++.JSfrontend: javascript

backend: elixir
HaskellHaskellC++HaskellCoffeeScriptany. host language implementations in typescript, c++, python, more in the worksC/C++cTypeScript/ReactJavaScriptJavaC++C# (but have been wanting to port it elsewhere since the beginning)designing first, then we'll seeAS3, JStypescriptDarkrustbackend: python + llvm; front: JS/reactstandard ML and TypeScriptrust, jsC#Java
Web-basednoyes + CLI + IDE toolingyesnonocurrentlyyesnonot currentlynext version will beyesyeslots of tree stuff is on the webnoyesBrowser basedfundamentallynonohas dedicated Wasm backendnot specificallyonly for product delivery, development on Mac/Winnoyesyesyesweb-based editor in progress:
Development platforms supported (mac, win, linux, ios, android, web)mac + win + linuxmac + windows + linux + Ethereum contracts + Raspberry Piall (to different extent)NodeJS, Docker, Kubernetes, or Ubuntu Snapat least win + mac + linux*nixweb
mac + windows + linuxmac, linuxmax, linuxwebany. supports pen and paper too!always-on, no dev phaseBrowserMacOS, Windows, Linuxmac + windows + linuxwin + linux + macanymac + win desktop, Linux (with Wine installed)web, currently focused on generating server-side back-endsmac + windows + linux + webbrowsermac/win/linuxwin (.net + wpf)win + linux + mac
Output target platforms (mac, win, linux, ios, android, web client, web server, game consoles, VR/AR, embedded)mac + win + linuxnoanything program components supportweb, and WebVR (via Aframe). AR in developmentmac + win + linux + consolesMuweb
mac + windowsmac, linux, maybe VR in futurewebwebtree languages run on anyAndroid, Linux, PinetimeBrowser, desktop via electronmac, win, web via electron, some IOT via NexusMacOS, Windows, Linuxmac + windows + linuxwin + linux + mac + ios + android + wasm/web + steamvralmost any (via Blazor, mono, .NET Core)web apps, mac + win desktop, Node.JS server side, Android/IOS for mobilemac, win, weblinux backend server to support web appsmac, win, web, embeddedanything LLVM will targetall programs are interpretedwin, possibly monowin + linux + mac + android?
Tools available (compiler, interpreter, debugger, lint)compiler, interpreter, not sure if debugger availcompiler, editor, live data inspectorcompiler, editor, basic debuggertranslator; time-travel debuggerlive codingat the moment "live debugging" and transpiler to JSlive coding environmentcompilerlive graphics environmentcompiler compilers, grammar builders, interpreters, debuggers, web frameworks, syntax highlighter generators, type checkers, etcIDEfully visual environment; automatic visualization of nested hierarchical results; highlighting spreadsheet-like formula editorcompiler uses LLVM, debuggercompilerparsers, printers, syntax highlighting for Notepad++ and Visual Studiotranspiler, debugger in progresscompilerinterpreter and debugger integrated in editor/languagecompilerlive codingcommand-line interpreter, browser editorIDE + compilerIDE + compiler
Networked to the core, or provided by a libraryin corelibrarylibraryin librarynocorenonono, but would be cool for a tree language that did this!to coreyesSelf-contained distributed execution, eventuallyto whatever extent JS is networkeddelegates execution to external database server (PostgreSQL, MySQL, Oracle, or Microsoft SQL Server)nonoin languagein coreyesnonoyes, can run distributed computations