ProjectLuna EnsoRed (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)ParasailLobsterLESHilltopCeptreBeadsMaracaDarkMechLynxtoolLeibnizEveRestructorAardappel
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 SwirskyChris MartensEdward de JongJon WhiteheadPaul Biggar, Ellen ChisaCorey MontellaTim BabbKonrad HinsenChris 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. 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.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.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.Digital Scientific Notation: a formal language designed for encoding scientific models embedded into narrratives (as in Literate Programming). Turing-complete but not really meant for "programming".Structured programming with fully automatic whole program code refactoringGraphical Concurrent Tree Rewriting: Program by example visual programming with concurrent/distributed computing.
Active/Dormant/ArchivedActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveActiveDormantActiveActiveActiveActiveActiveActiveActiveActiveActive (struggling for time)ActiveActiveActiveActiveActiveActiveActiveActiveArchivedArchivedArchived
5 enso.org
Web editor prototype:
Github URL
Private repositories, see website for
Twitter URL (main one for you or project)
Open or commercial or mixopen (I think) mixapparently 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 prototypeopenCommercialopenopenopenopenopenmixopenmixopencommercialopenopenopenopen
If commercial, name of companyNew Byte Order Inc.Red 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 time1111111111111 (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)20092011201220142014long gestation20172018201820192020201620152016
CountriesPolandChina, Europe, US, SerbiaUSAUSAUK, HungaryDistributedUSAUSASuomi (aka Finland)Argentina, Portugal, GermanyIsraelUSA, remoteCanadaCroatiaCanadaUSA, IndiaUKUSAUSAUSAUSAUSACanadaIsraelUSUSAUKUSAUSAUSAFranceUSAUSAUK
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.Designed to be distributed-first. Code is stored in a database, not text files.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 changeslinear logic programming and stagesA 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).Based on term rewriting. Fully declarative. Syntax designed for embedding into prose, like mathematical notation.Automatically 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 Haskellyesyesit's a programming systemit'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.)yesyesyesyesyesyesyesnoyesyesyes
It's an IDEyesnokinda!yesyesnoMuincludes an IDEyesyesyesyesnoit's a programming systemnoyesyesyeseventuallyyesnononoyesnononoyesyesyesyesyesyesyes
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)nononononoit's a programming systemnoyeseventuallyeventuallyin a loose sense, will have "drivers" etc.nononononononononoyes (see
Live programmingyesyesyesyesyessuperfast compilernoyesyesyeshopefullyyesyestree languages can supportyesyesyesyesyesinstant startupnonononot yetyesyesyesyesyesnono
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 imperativedeclarativecombines 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 first (considering terms as "state")state laststate last
static, strictly, dynamically typed, untypedbased on Haskelldynamicstatic, strictlystatic, 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 specializationanystaticstrictly typedstatic, strongly typed with an escape hatchstatic, strictlyuntypedhindley-milnersemi-statically typed (static coarse-grained typing, dynamic fine-grained)untypedstatic, inferreddynamically typed
Pure functional in whole or in partyesnoyesin partnononopureyespurepure functionalnotree 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 partnohyperfunctional (code compiles to a thicket of composed calls, 2 function calls per line avg)almostnopurepurenoimpureimpure
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/Ayeskindanoseminonoyesnono
Elements of constraint programmingnonoIn development so that methods can be found based on example inputs and outputsnonot yetnonononoyou can build constraint tree languagesnoyesnosome, via "lenses to self"nonoN/Anoyes, lots of constraint language usednoyesnonoyesnono
Based on FRPyesnonofundamentally, but hiddenit's reactive and functionalnonoeasy-to-use mix of FRP and Elm Architecturenoyou 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 cellsnohas event model in the languagea littlenononono
Based on Object Oriented Paradigm?based on REBOLnoyes, Visual basic 6noyesyesnonononoyou can build oo tree languagesnonononovery much optionallyN/Anonocomplete 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-modificationnononoyesyesyesnot in terms of syntax as in LISP; yes in terms of semanticssignificantlynonoyesnonono self-modifying code, but you do have a fancy preprocessor with aliasing, shortcuts, compile time IF, etc.noyesnot currently, but likely at some point.yes, it's terms all the way downyesnokinda, 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 rangesallall rangesintermediateadvancedall rangesearly: non-coders. late: everyone, coders included.intermediate, domain experts (computational science)all 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 adoptionfor motivated users at this timeprogram 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 inRust and ScalaRed (itself), REBOLHaskellTypeScript, 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 seestandard ML and TypeScriptAS3, JStypescriptDarkrustbackend: python + llvm; front: JS/reactPharo Smalltalkrust, jsC#Java
Web-basednoyes + CLI + IDE toolingyesnonocurrentlyyesnonot currentlynext version will beyesyeslots of tree stuff is on the webnoyesBrowser basedfundamentallynonohas dedicated Wasm backendnot specificallyweb-based editor in progress: for product delivery, development on Mac/Winnoyesyesyesnoyesnono
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/linuxmac + win desktop, Linux (with Wine installed)web, currently focused on generating server-side back-endsmac + windows + linux + webbrowserlinux + mac + windowswin (.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)all programs are interpretedweb 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 targetsame (live environment)win, 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 Studiocommand-line interpreter, browser editortranspiler, debugger in progresscompilerinterpreter and debugger integrated in editor/languagecompilerlive codingauthoring system with exploration functionalityIDE + compilerIDE + compiler
Networked to the core, or provided by a libraryin corelibrarylibraryin librarynocorenononono, 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)nononoin languagein coreyesnonoyes, can run distributed computations