"No Programming Needed" Game Editors and Visual Programming

Blueprints - Unreal Engine Visual Scripting (Free & Open Source & Commercial)
https://docs.unrealengine.com/latest/INT/Engine/Blueprints/index.html

Node-based scripting system of Unreal engine, can be extended with C++ programming.
Links: http://blueprintue.com/ (Pastebin for Blueprints)

Blender Game Engine - Logic Editor (Free & Open Source)
https://www.blender.org/manual/editors/logic_editor.html

Event driven logic bricks, can be extended through Python scripting.

Amazon Lumberyard (CryEngine) - Flow Graph System (Free with Full Source & Commercial)
https://aws.amazon.com/en/lumberyard/
https://www.cryengine.com/features/sandbox-tools#features/flowgraph

Visual scripting system to implement complex game logic without code.

WIMI5 (Free)
http://wimi5.com/

Html5 game editor with node-based visual programming.

Scratch (Free & Open Source)
https://scratch.mit.edu/
http://wiki.scratch.mit.edu/wiki/Blocks

Blocks based visual programming language.
Similar Tools: Stencyl (Free & Commercial)

Blocky
https://developers.google.com/blockly/

Javascript library by Google, for building visual programming editors.

Gdevelop (Free & Open Source)
http://compilgames.net/

Event based system, can be extended using Javascript (HTML5 target), or C++ (Native target).
Similar Tools: Construct 2 (Free & Commercial)


Note: Basically, there are two most popular types of visual programming as scripting system in game editors - node & wire based and block based. My personal favorite is block based, more specifically, GDevelop-style. The reason is the presentation of logic in block based visual programming is "linear". Node & wire based visual programming is very flexible, but as the presentation can be non-linear ("messy"), it usually has low readability (just think the "wires" as the notorious keyword "goto"). Block based is more similar to line by line text-based structured programming, and it is easier to structure and organize, and hence usually have better readability. Scratch and blocky are too similar to text-based programming and almost have no advantages over text-based programming, so I think most programmers would not bother using them. GDevelop gives a better example of block type - the event driven, condition & action approach is very intuitive and convenient.

Others:
Goo Create (Free & Commercial)
http://goocreate.com/
Goo Create open source online WebGL game editor has a state machine visual programming system.

AS3 Eval/Scripting Engines

AS3 Scripting Lib:

Compile AS3/JavaScript at runtime within the Flash Player
Execute compiled code in the scope of any object
Control which classes and functions are exposed to the script domain

https://code.google.com/p/as3scriptinglib/

D.eval:

The D.eval API brings the eval() functionality to ActionScript3 programming.

http://o-minds.com/deval/
http://www.riaone.com/products/deval

Runtime expression evaluation in ActionScript:
http://www.sephiroth.it/weblog/archives/2008/04/runtime_expression_evaluation_in_acti.php

ActionScript 3 Mathematics Expression Parser:
http://www.flashandmath.com/intermediate/mathparser

Lua for Flash:
http://code.google.com/p/lua-alchemy/ (Lua for Flash via Alchemy)
https://github.com/adobe-flash/crossbridge/tree/master/samples/Example_Lua
http://gonchar.me/blog/goncharposts/2121 (Lua for Flash via CrossBridge)
https://github.com/chadrem/easy_lua (Another Lua for Flash port using CrossBridge)
http://code.google.com/p/lufacode/ (Lua for Flash in pure AS3)

ActionScript 3 Eval Library:

As3Eval is a library that packages the Tamarin ESC compiler to work within a run-of-the-mill flash player.

http://eval.hurlant.com/

Governor:

Governor is a script engine written in AS3. It provides all functions and operators you know from AS3; operators, math functions, math constants. Additionally it provides multithreading functionality for parallel execution of code. !The flash player is design as a single thread application, so governor is providing green threads! 

http://code.google.com/p/governor/

BISE Scripting Engine:(Recommended)

The AS2-based engine could run a subset of ECMAScript, and it allowed users to write interpreted scripting for Flash games or applications. It also had some useful features, such as coroutines, a type of function that had the ability to suspend in the middle of its scripting.

http://kinsmangames.wordpress.com/bise-scripting-engine/ (AS3 Port)
http://kinsmangames.com/beinteractive-scripting-engine-bise-as3-port/
http://sourceforge.net/projects/biseas3/files/beinteractivescriptingengine_as3port_version104.zip/download
http://www.be-interactive.org/index.php?itemid=7 (AS2)

eval() for Actionscript 3:
http://www.brainblitz.org/anthony/130

AS3 Commons Bytecode:

AS3Commons-bytecode is an open-source library providing a ABC bytecode parsing and publishing and bytecode based reflection API for ActionScript 3.0. 

http://www.as3commons.org/as3-commons-bytecode/

XML to ActionScript(asXML):
http://actionsnippet.com/?p=1611

TinyBasicAS: Flex version of TinyBasic
http://www.thisiscool.com/tinybasicas.htm

Java runs in Flash-Waba VM Alchemy:
http://www.thisiscool.com/j2f.htm

The brainfuck programming language interpreter:
http://blog.onthewings.net/2009/10/08/brainflash-the-as3-brainfuck-interpreter/
http://wonderfl.net/c/njuL

Ascript:
http://code.google.com/p/ascript-as3/
https://github.com/softplat/ascript

hscript:
Parse and evalutate Haxe expressions. Haxe script is a complete subset of the Haxe language.
https://github.com/HaxeFoundation/hscript

Simplified JavaScript interpreter:
A JavaScript interpreter you can embed in your Flash ActionScript 3 projects. Can parse and execute most JavaScript and support async "await" statement that pauses the VM until a Promise is fulfilled.
https://github.com/sixsided/Simplified-JavaScript-Interpreter

AS3 Eval Draw - Eval the AS3 drawing API!

Inspired by Ken Silverman's EVALDRAW(http://www.advsys.net/ken/evaltut/evaldraw_tut.htm),
I made this little project, AS3 Eval Draw, used to quickly test the AS3 drawing API on the fly without compiling the AS3 code. Thanks to BISE Scripting Engine, an easy to learn and use but powerful scripting engine, making everything simple. The grammar of BISE Scripting Engine is similar to AS3 and makes it easy to export the eval scripts to AS3.
I use BIT-101’s MinimalComps for the UI and Atlas's syntax highlighter to highlight the code.

AS3 Eval Draw now supports very simple AS3 drawing API, mostly 2D graphics & Bitmapdata manipulation. I also implemented other basic functions, such as load/save code, screen print and export AS3.
It is not hard to make it support text displaying and the new AS3 3D drawing, sounds generation API. Another useful thing is loading function so we can play with picture assets and use them as textures. Supporting more AS3 events (like keyboard & mouse events) will be helpful too. We can then make some little games at run-time!
Now I just like it simple as this.
One limitation is speed. Luckily the Eval Draw script can easily be ported to AS3 (thanks to BISE Scripting Engine again!).

Full source code of the project:
http://flaswf.googlecode.com/svn/trunk/AS3_Evaldraw_En/
Feel free to use it and fork it!
Play it now:
Click "Eval" to run the example code, click "Canvas" to see the result in action.
More examples:
(thanks to Zevan Rosser - http://actionsnippet.com/)
http://flaswf.googlecode.com/svn/trunk/AS3_Evaldraw_En/Evaldraw_examples/

Links:
1. Ken Silverman's EVALDRAW
http://www.advsys.net/ken/evaltut/evaldraw_tut.htm
2. BISE Scripting Engine (AS3) by Yoshihiro Shindo and Sean Givan
http://kinsmangames.wordpress.com/bise-scripting-engine/
3. MinimalComps by Keith Peters (BIT-101)
http://www.minimalcomps.com/
4. Atlas's Syntax Highlighter
http://www.atlascs.co.uk/blog/2007/02/09/as3-syntax-highlighting-in-as3
5. http://actionsnippet.com/
6. A similar project using D.eval()
http://insideria.com/2008/03/try-out-the-drawing-api-withou.html