Commercial License?

Monkey Forums/Monkey Beginners/Commercial License?

RedGTurtlepa(Posted 2015) [#1]
Anyone have a copy of the terms of use for the program? Only reference to any license I see is a small txt file stating that Monkey X is under zlib license. And I was confused as the store page says "Full commercial License" but only for some. Can someone show me the full (basic) Monkey X usage license and a copy of the commercial ones aswell?

Xaron(Posted 2015) [#2]
Monkey itself is open source. Mojo (the 2d framework) is NOT. You have no restrictions with the full version of Monkey.

RedGTurtlepa(Posted 2015) [#3]
Oh so the license covers BlitzMax's module Mojo which is what? Is it like Unity's built in renderer device that you license directly from BlitzMax?

Also, are there any terms I should be aware of for use of Mojo and if you don want to use Mojo what does Monkey allow? Besides OpenGL I read. Is there any examples I can find where I can see how someone used monkey without Mojo to make images and such?

ImmutableOctet(SKNG)(Posted 2015) [#4]
@RedGTurtlepa: Monkey is its own language, it's only based off of BlitzMax's syntax. As Xaron said, Monkey itself is open source, and you can download the free version. The free version comes with the native source code for two of Monkey's targets (HTML5 and GLFW/Desktop). When you buy Monkey, you're getting the other native implementations of Mojo. For example, the full version of Monkey comes with the Mojo source code for the Android target. In addition to this, you get bug fixes and experimental releases. There are also bundles available, which ship Monkey with IDEs and other framework(s).

As far as licenses go, you're free to do anything under the ZLIB license with Monkey's source code. But for commercial games, you're not in any way limited, even with the free version. The only exception is redistributing the commercial/private source code of Monkey. In other words, if you buy the "pro"/commercial version, you can't redistribute the closed source components of it (Currently the native source for Mojo). However, regardless of the version of Monkey, you can redistribute games built with it.

I can't stress this enough: Monkey is not BlitzMax. Monkey basically takes from BlitzMax's syntax, and expands it to be less platform dependent. This also means you can't directly use lower-level hardware features in Monkey, such as pointers. Threads are also a bit of an issue, as they are platform dependent. Mojo (As well as a number of Monkey's modules) have asynchronous routines you can use. For example, loading resources on another "thread" (How it's implemented depends on the target). That's one of the downsides, but that tends to be more of an abstraction thing than a performance one.

If you wish to use BlitzMax with Monkey, there is a third-party (Community driven) target for it, but there isn't much of a point to it anymore. Unless you absolutely have to use BlitzMax source, it's best to just use the GLFW/Desktop target(s) for those builds.

At its core, Monkey's compiler, 'Trans', is a "transpiler" (Source to source compilation), meaning it compiles your code written in Monkey into the target's native language. For example, the GLFW/Desktop target compiles down to C++ code. Implementations for language features (Such as strings, and arrays) depend on the target, and may use in-house solutions. With that in mind, Monkey is technically a "higher level" language than say, C# or Java, as it depends on implementations of these languages to build.

To answer the question of using Monkey's OpenGL APIs/modules, there are a few examples in the "bananas" folder, found in every current distribution of Monkey. Generally, using OpenGL in Monkey is similar to the wrappers found in other languages, like Java. The difference is, the code you write in Monkey could use any number of OpenGL backends. For example, the GLFW target directly interfaces with GLEW (Directly interfacing with the API), and the HTML target provides WebGL support. In general, unless you're planning on writing the lower level components of the pipeline, using OpenGL isn't the best choice. Monkey's 'mojo' module is provided for free on the GLFW and HTML5 targets, so unless you plan to modify it, you'll probably want to use that. Mojo's underlying source is target-dependent, so this also means the APIs used are different between most targets. Despite this, Mojo provides an API which does not directly depend on any particular API. This is how Monkey is able to deploy to so many targets.