lua-users home
lua-l archive

[Date Prev][Date Next][Thread Prev][Thread Next] [Date Index] [Thread Index]

On Thu, Jul 10, 2014 at 5:57 PM, Steven Degutis <> wrote:
Hello again.

As I mentioned in other posts, I've recently started embedding Lua
into my Objective-C (OS X) applications. Besides my short stint trying
to use and configure "awesome" (a window manager), this has been my
first real in-depth usage of Lua.

I really like where it is now! But I realize it has not always been
where it is now. Even as recently as Lua 5.1, there have been breaking
changes. But Lua has gone through massive changes from the time it was
publicly released at 1.1 all the way through the current 5.2. Not just
in the C API, but in syntax and semantics. Much of this was added
complexity, but fortunately it's all remained very orthogonal so far
and still relatively simple compared to other "scripting languages".

Lua's API stability improved  dramatically from 4.0 onward. I would consider pre-4.0 to
be development versions at this point. In practice, the oldest code you'll ever see is
Lua 4.0 (and I'd be surprised if you only saw Lua 5.0).

Within the 5.x epoch, it's been very easy for me to migrate my Lua code from version
to version. Any breaking changes have been well-documented, and Lua itself has
a very good specification to work from. (Perhaps the only thing that was troublesome was the
addition of __ENV and the removal of setfenv for 5.2, but the migration was not impossible).

Now, looking at the timeline page[1], it looks like development is
rapidly declining. There have only been 4 years between 1.0 and 3.0, 3
years between 3.0 and 4.0, 3 years between 4.0 and 5.0 which was
released 11 years ago, and since then we've been seeing only minor
version changes.

It makes sense that Lua's development "progress" (for lack of a better
word) would be rapidly declining, if its features are stabilizing to
the point where it's good enough for the purpose it sets out for: to
be the ideal general purpose language to embed in a C host.

But a very small part of me is concerned that it will continue to grow
in breaking ways, eventually adding a disproportionate amount of
complexity simply for the sake of continuing to work on it when
there's nothing left to work on.

This opinion depends on who you are, really. I'm excited for the addition of binary operators in 5.3, for example, but the upstream developers do not seem to add features arbitrarily. It truly is a solid project.

So what is the long-term roadmap? What's the plan after 5.3 is
released? Are there any major features for 6.0? I ask out of
curiosity, and to get a general idea of the roadmap which I may use to
form a long-term plan of my own personal future using Lua for

As far as I've seen, public discussion doesn't extend past 5.3, but this is likely due to the Lua API's demonstrated usefulness (rather than stagnation). There just isn't a good reason currently to make major changes to the API, so there's no need to bump from 5 to 6.

Lua's biggest downside is that they don't have an publicly accessible source code repository - the developers distribute work versions and releases via tarballs. The lack of public access to real-time development is a significant impediment to public involvement. Fortunately, that's about the only concern from this release-engineering angle that should give you pause.

-- Aaron Faanes

Aaron Faanes <>