

Aroma: A game creation framework for Lua - fosk
http://leafo.net/aroma/

======
leafo
Kinda surprised seeing this here. I made this project 2 years ago and haven't
updated it since. It was an interesting proof of concept, but I only took it
far enough to run a couple of my games. The only takeaway was that I was
really disappointed with the performance of native client OpenGL.

The modern version of Love supports OpenGL ES though so a rewrite like this
isn't required, a better approach would just be to try to compile Love.

If you want to see more cool stuff I've done with Lua:

Moonscript: [http://moonscript.org](http://moonscript.org)

Lapis: [http://leafo.net/lapis](http://leafo.net/lapis)

~~~
srean
Hi Leafo I have tried to get in touch a couple of times. Question: Does
Moonscript have coroutines ? In case it doesnt, is there a way to use Lua's
coroutines together with Moonscript ? In case it does, could you point me to
the syntax, couldnt find it in the docs.

~~~
anonymoushn
Yes, it does.

~~~
anonymoushn
Sorry, I can no longer edit my comment above. You just use Lua coroutines.

For people unfamiliar with Lua coroutines, there is no extra syntax for them.
There are functions coroutine.create, coroutine.resume, and coroutine.yield.
They do about what you'd expect them to do. If you're familiar with greenlet,
the first function is greenlet() and the second two functions do the job of
greenlet.switch().

Here is some Moonscript Leafo wrote using coroutines:
[https://gist.github.com/leafo/6788652](https://gist.github.com/leafo/6788652)

~~~
srean
Awesome, cant thank enough.

------
anonfunction
I've been seeing a lot more of Lua as of late, in seems to be catching steam
in all corners of the industry from games to infrastructure.

~~~
herokusaki
There's a lot to like about Lua, especially when you compare its speed to that
of reference Python or Ruby, but the weak typing makes me reluctant to try it
for a larger project. I almost wish there was a TypeScript for Lua.

~~~
alloyed
Technically, Lua is a strongly typed dynamic language: it's just that most
things happen to be of a single "supertype" (the table). If you need a more
rigorous approach, Lua's integration with C is good enough that you can write
the architectural bits in C/C++ and just use Lua for the long tail of
behaviors, or go one bit better and use a language like Terra [1] that
provides a C-like static language inline with your Lua code.

[1]:[http://terralang.org/](http://terralang.org/)

------
fiblye
>Aroma implements parts of the LÖVE Lua API, so if you've got a game already
written it’s easy to port.

>In the future Aroma hopes to implement the whole LÖVE API

Love has been growing quite a bit among small indie developers lately, so I'm
glad they did this. I hope it doesn't take too long to fully implement it.

------
jbeja
Leafo you are like "Tj Holowaychuk" of Lua, but actualy real :D.

------
null_ptr
So Google Chrome is now the "portable" C/C++ runtime that developers are
encouraged to code for? Why must native applications take a dependency on
Google's web browser again?

~~~
pekk
Because it's so much better to transpile to Javascript

~~~
null_ptr
At least JavaScript runs in all web browsers not just Chrome.

~~~
pekk
Others could support something else whenever they chose.

~~~
null_ptr
What's the point of supporting something _else_ , the goal of the web is to be
_genuinely_ portable and accessible to every client.

