Daniel Kolesa explains how LuaJIT and the Enlightenment Foundation Libraries (EFL) can be used together to create robust user interfaces.

1. High level application scripting
with Enlightenment Foundation Libraries and LuaJIT
Daniel Kolesa
Samsung Open Source Group
d.kolesa@osg.samsung.com
@octaforge
Lua Workshop 2015 Stockholm

2. The Problem
What are we dealing with?

3. What is the EFL?

4. What is the EFL?
A suite of graphics (and other) libraries

5. What is the EFL?
A suite of graphics (and other) libraries
A widget toolkit

6. What is the EFL?
A suite of graphics (and other) libraries
A widget toolkit
Originally written for the Enlightenment window manager

7. What is the EFL?
A suite of graphics (and other) libraries
A widget toolkit
Originally written for the Enlightenment window manager
Scalable to both embedded and desktop systems

8. What is the EFL?
A suite of graphics (and other) libraries
A widget toolkit
Originally written for the Enlightenment window manager
Scalable to both embedded and desktop systems
Lightweight, written in C

9. What is the EFL?
A suite of graphics (and other) libraries
A widget toolkit
Originally written for the Enlightenment window manager
Scalable to both embedded and desktop systems
Lightweight, written in C
Significant usage includes Samsung’s Tizen platform

10. EFL components

11. EFL components
Historically, several projects with individual build systems

12. EFL components
Historically, several projects with individual build systems
Merged in version 1.8

13. EFL components
Historically, several projects with individual build systems
Merged in version 1.8
EFL - the core library set

14. EFL components
Historically, several projects with individual build systems
Merged in version 1.8
EFL - the core library set
ELementary - the widget toolkit built on the EFL

15. EFL components
Historically, several projects with individual build systems
Merged in version 1.8
EFL - the core library set
ELementary - the widget toolkit built on the EFL
Some others still separate - Evas generic loaders etc.

16. Evas

17. Evas
The oldest EFL component

18. Evas
The oldest EFL component
A scene graph canvas

19. Evas
The oldest EFL component
A scene graph canvas
Represents the canvas as state with Evas objects

20. Evas
The oldest EFL component
A scene graph canvas
Represents the canvas as state with Evas objects
Provides several core primitives (rectangles, images etc.)

21. Evas
The oldest EFL component
A scene graph canvas
Represents the canvas as state with Evas objects
Provides several core primitives (rectangles, images etc.)
Widgets provided by other libraries are Evas objects

22. Ecore

23. Ecore
Provides the interface between the OS and the rest of the EFL

24. Ecore
Provides the interface between the OS and the rest of the EFL
Interaction with X11, Wayland, SDL, Cocoa, DirectX etc.

25. Ecore
Provides the interface between the OS and the rest of the EFL
Interaction with X11, Wayland, SDL, Cocoa, DirectX etc.
Provides a main loop for applications

26. Ecore
Provides the interface between the OS and the rest of the EFL
Interaction with X11, Wayland, SDL, Cocoa, DirectX etc.
Provides a main loop for applications
Also several other unrelated things

27. Edje

28. Edje
Edje is a layout/UI description language

29. Edje
Edje is a layout/UI description language
It is also a way to compile said language together with data

30. Edje
Edje is a layout/UI description language
It is also a way to compile said language together with data
The result can be loaded from the application and used as UI

31. Edje
Edje is a layout/UI description language
It is also a way to compile said language together with data
The result can be loaded from the application and used as UI
Separation of UI/layout and application logic

32. Edje
Edje is a layout/UI description language
It is also a way to compile said language together with data
The result can be loaded from the application and used as UI
Separation of UI/layout and application logic
Widgets provided by libs can be embedded in Edje

33. Elementary

34. Elementary
A widget toolkit

35. Elementary
A widget toolkit
Provides a large set of widgets as Evas objects

36. Elementary
A widget toolkit
Provides a large set of widgets as Evas objects
Can be used standalone (boxed style layouting defined from C)

37. Elementary
A widget toolkit
Provides a large set of widgets as Evas objects
Can be used standalone (boxed style layouting defined from C)
Can be used with Edje (Elementary widgets, Edje layout)

38. Eo

39. Eo
An object system for the EFL

40. Eo
An object system for the EFL
The base for everything EFL 2.0

41. Eo
An object system for the EFL
The base for everything EFL 2.0
Allows for backwards compatible legacy APIs

42. Eo
An object system for the EFL
The base for everything EFL 2.0
Allows for backwards compatible legacy APIs
Provides everything one would expect from an object system

43. Eo
An object system for the EFL
The base for everything EFL 2.0
Allows for backwards compatible legacy APIs
Provides everything one would expect from an object system
Much of EFL 2.0 API is interfaces

44. Eo
An object system for the EFL
The base for everything EFL 2.0
Allows for backwards compatible legacy APIs
Provides everything one would expect from an object system
Much of EFL 2.0 API is interfaces
We aim for API and ABI stability

45. Overview

46. Overview
Sick and tired of writing apps in C

47. Overview
Sick and tired of writing apps in C
There has to be a better way

48. Overview
Sick and tired of writing apps in C
There has to be a better way
Scripting languages?

49. Overview
Sick and tired of writing apps in C
There has to be a better way
Scripting languages?
They kind of suck

50. Why is that?

51. Why is that?
Slow

52. Why is that?
Slow
Lack of a proper type system

53. Why is that?
Slow
Lack of a proper type system
Tons of bloat we don’t need

54. Why is that?
Slow
Lack of a proper type system
Tons of bloat we don’t need
Inconvenient binding

55. Why is that?
Slow
Lack of a proper type system
Tons of bloat we don’t need
Inconvenient binding
Resource heavy

56. Why is that?
Slow
Lack of a proper type system
Tons of bloat we don’t need
Inconvenient binding
Resource heavy
Battery eating

57. Why is that?
Slow
Lack of a proper type system
Tons of bloat we don’t need
Inconvenient binding
Resource heavy
Battery eating
Could there be a solution?

58. Scripting language overview

59. Python

60. Python
An obvious choice at first

61. Python
An obvious choice at first
Tons of problems

62. Python
An obvious choice at first
Tons of problems
Slooooow

63. Python
An obvious choice at first
Tons of problems
Slooooow
Bloated

64. Python
An obvious choice at first
Tons of problems
Slooooow
Bloated
No decent unified API

65. Python
An obvious choice at first
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to embed

66. Python
An obvious choice at first
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to embed
Language design issues

67. Ruby

68. Ruby
A not so obvious choice

69. Ruby
A not so obvious choice
Tons of problems

70. Ruby
A not so obvious choice
Tons of problems
Slooooow

71. Ruby
A not so obvious choice
Tons of problems
Slooooow
Bloated

72. Ruby
A not so obvious choice
Tons of problems
Slooooow
Bloated
No decent unified API

73. Ruby
A not so obvious choice
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to embed

74. Ruby
A not so obvious choice
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to embed
Language design issues

75. Perl

76. Perl
You serious?

77. Perl
You serious?
Tons of problems

78. Perl
You serious?
Tons of problems
Slooooow

79. Perl
You serious?
Tons of problems
Slooooow
Bloated

80. Perl
You serious?
Tons of problems
Slooooow
Bloated
No decent unified API

81. Perl
You serious?
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to... ok that’s enough

82. JavaScript

83. JavaScript
Popular these days

84. JavaScript
Popular these days
Fairly decent quality JIT implementations

85. JavaScript
Popular these days
Fairly decent quality JIT implementations
Each implementation has its own weird API

86. JavaScript
Popular these days
Fairly decent quality JIT implementations
Each implementation has its own weird API
Language is pretty bad

87. JavaScript
Popular these days
Fairly decent quality JIT implementations
Each implementation has its own weird API
Language is pretty bad
But probably a better choice than the above

88. Io, Self, Squirrel etc.

89. Io, Self, Squirrel etc.
Many different choices

90. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters

91. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters
Some are decent languages

92. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters
Some are decent languages
Mostly fairly light on resources

93. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters
Some are decent languages
Mostly fairly light on resources
Not good enough

94. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters
Some are decent languages
Mostly fairly light on resources
Not good enough
People would look at us weird

95. Lua

96. Lua
A popular scripting language

97. Lua
A popular scripting language
Good language with a few quirks

98. Lua
A popular scripting language
Good language with a few quirks
Light on resources

99. Lua
A popular scripting language
Good language with a few quirks
Light on resources
Great embedding API

100. Lua
A popular scripting language
Good language with a few quirks
Light on resources
Great embedding API
Interpreted... :(

101. Lua
A popular scripting language
Good language with a few quirks
Light on resources
Great embedding API
Interpreted... :(
LuaJIT saves the day

102. Why is LuaJIT awesome?

103. Why is LuaJIT awesome?
One of the fastest JIT compilers around

104. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources

105. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios

106. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios
The exact same API as Lua!

107. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios
The exact same API as Lua!
API and ABI compatible with Lua 5.1

108. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios
The exact same API as Lua!
API and ABI compatible with Lua 5.1
Portable bytecode

109. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios
The exact same API as Lua!
API and ABI compatible with Lua 5.1
Portable bytecode
We have a winner

110. Why LuaJIT sucks

111. Why LuaJIT sucks
VM written in assembly - only a handful of architectures

112. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough

113. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough
Classic Lua C API is not JITed

114. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough
Classic Lua C API is not JITed
A handful of other things not JITed

115. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough
Classic Lua C API is not JITed
A handful of other things not JITed
No multithreading support

116. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough
Classic Lua C API is not JITed
A handful of other things not JITed
No multithreading support
LuaJIT 2.1 significantly improves the situation

117. Elua

118. What is it?

119. What is it?
An application runtime

120. What is it?
An application runtime
Ships with the EFL

121. What is it?
An application runtime
Ships with the EFL
Lightweight

122. What is it?
An application runtime
Ships with the EFL
Lightweight
Reusable

123. What is it supposed to achieve?

124. What is it supposed to achieve?
Rapid application development

125. What is it supposed to achieve?
Rapid application development
Clean, high level code

126. What is it supposed to achieve?
Rapid application development
Clean, high level code
Lightweight, good performance

127. What is it supposed to achieve?
Rapid application development
Clean, high level code
Lightweight, good performance
Easier app distribution (app store model)

128. What is it supposed to achieve?
Rapid application development
Clean, high level code
Lightweight, good performance
Easier app distribution (app store model)
More safety (memory etc.)

129. How does it work?

130. How does it work?
Elua library and binary

131. How does it work?
Elua library and binary
Library provides Elua-related C utilities for the Lua state

132. How does it work?
Elua library and binary
Library provides Elua-related C utilities for the Lua state
Binary is a minimal application launcher

133. How does it work?
Elua library and binary
Library provides Elua-related C utilities for the Lua state
Binary is a minimal application launcher
Together they set up Lua state + ecore main loop

134. How does it work?
Elua library and binary
Library provides Elua-related C utilities for the Lua state
Binary is a minimal application launcher
Together they set up Lua state + ecore main loop
Most of Elua is written in Lua itself

135. Bindings

136. Bindings
Any decent application runtime needs APIs

137. Bindings
Any decent application runtime needs APIs
Writing bindings is a pain in the ass

138. Bindings
Any decent application runtime needs APIs
Writing bindings is a pain in the ass
Maintaining bindings is a bigger pain in the ass

139. Bindings
Any decent application runtime needs APIs
Writing bindings is a pain in the ass
Maintaining bindings is a bigger pain in the ass
What do?

140. Eolian

141. Eolian
Two things

142. Eolian
Two things
An API description language we invented

143. Eolian
Two things
An API description language we invented
A library to parse this language and expose the information
via API

144. Eolian
Two things
An API description language we invented
A library to parse this language and expose the information
via API
We describe our EFL APIs in it

145. Eolian
Two things
An API description language we invented
A library to parse this language and expose the information
via API
We describe our EFL APIs in it
We can reuse it to generate bindings

146. Eolian
Two things
An API description language we invented
A library to parse this language and expose the information
via API
We describe our EFL APIs in it
We can reuse it to generate bindings
No maintenance burden

147. Lualian

148. Lualian
Lualian is the Elua binding generator

149. Lualian
Lualian is the Elua binding generator
Itself a Lua application powered by Elua

150. Lualian
Lualian is the Elua binding generator
Itself a Lua application powered by Elua
Easy to maintain and high level

151. Lualian
Lualian is the Elua binding generator
Itself a Lua application powered by Elua
Easy to maintain and high level
Bindings generated at EFL build time

152. How do our bindings work?

153. How do our bindings work?
LuaJIT provides a foreign function interface (FFI)

154. How do our bindings work?
LuaJIT provides a foreign function interface (FFI)
This allows us to directly access C APIs

155. How do our bindings work?
LuaJIT provides a foreign function interface (FFI)
This allows us to directly access C APIs
Lualian generates FFI-powered bindings

156. Eo and Elua

157. Eo and Elua
We have a Lua Eo layer

158. Eo and Elua
We have a Lua Eo layer
This provides a native-feeling Eo Lua core

159. Eo and Elua
We have a Lua Eo layer
This provides a native-feeling Eo Lua core
Handles callbacks, method resolution and other things

160. Eo and Elua
We have a Lua Eo layer
This provides a native-feeling Eo Lua core
Handles callbacks, method resolution and other things
Generated bindings properly register bound classes with this

161. Eo and Elua
We have a Lua Eo layer
This provides a native-feeling Eo Lua core
Handles callbacks, method resolution and other things
Generated bindings properly register bound classes with this
Native-feeling APIs!

162. Other Elua APIs

163. Other Elua APIs
Elua also provides a collection of Lua utilities

164. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system

165. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system
Also bindings to most relevant Eina components

166. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system
Also bindings to most relevant Eina components
Used by bindings

167. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system
Also bindings to most relevant Eina components
Used by bindings
Eo interacts with our Lua-side object system

168. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system
Also bindings to most relevant Eina components
Used by bindings
Eo interacts with our Lua-side object system
Completely transparent

169. Distribution

170. Distribution
Bundled with EFL → always available

171. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps

172. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps
Well supported - encouraging people to write apps

173. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps
Well supported - encouraging people to write apps
Closely matching EFL APIs → free documentation

174. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps
Well supported - encouraging people to write apps
Closely matching EFL APIs → free documentation
Needs self-contained package format (use eet?)

175. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps
Well supported - encouraging people to write apps
Closely matching EFL APIs → free documentation
Needs self-contained package format (use eet?)
Make it possible to run Elua apps on Tizen?

176. Status

177. Where are we?

178. Where are we?
Working, solid base

179. Where are we?
Working, solid base
Binding generator needs some work

180. Where are we?
Working, solid base
Binding generator needs some work
Elua library needs a lot of work

181. Where are we?
Working, solid base
Binding generator needs some work
Elua library needs a lot of work
EFL interfaces

182. EFL interfaces

183. EFL interfaces
A linked project

184. EFL interfaces
A linked project
Design and implement EFL 2.0 APIs

185. EFL interfaces
A linked project
Design and implement EFL 2.0 APIs
Eo based

186. EFL interfaces
A linked project
Design and implement EFL 2.0 APIs
Eo based
Why is this relevant to bindings?

187. Eo files

188. Eo files
Our current Eo files are not complete

189. Eo files
Our current Eo files are not complete
Missing enum definitions, structs etc.

190. Eo files
Our current Eo files are not complete
Missing enum definitions, structs etc.
Complete Eo files → validation is possible

191. Eo files
Our current Eo files are not complete
Missing enum definitions, structs etc.
Complete Eo files → validation is possible
Guaranteed definitions for types etc.

192. Eo files
Our current Eo files are not complete
Missing enum definitions, structs etc.
Complete Eo files → validation is possible
Guaranteed definitions for types etc.
Allows for proper binding generation

193. What does this all mean?

194. What does this all mean?
Our bindings are currently not fully functional

195. What does this all mean?
Our bindings are currently not fully functional
Many will fail to load because of missing type definitions

196. What does this all mean?
Our bindings are currently not fully functional
Many will fail to load because of missing type definitions
Dependencies are not correctly handled

197. What does this all mean?
Our bindings are currently not fully functional
Many will fail to load because of missing type definitions
Dependencies are not correctly handled
Elementary is not handled at all

198. What does this all mean?
Our bindings are currently not fully functional
Many will fail to load because of missing type definitions
Dependencies are not correctly handled
Elementary is not handled at all
Our demos work with what we have + manually adjusted
bindings

199. Other issues

200. Other issues
Internationalization and localization

201. Other issues
Internationalization and localization
Seamless VFS integrated with Lua IO streams

202. Other issues
Internationalization and localization
Seamless VFS integrated with Lua IO streams
Sandboxing

203. Other issues
Internationalization and localization
Seamless VFS integrated with Lua IO streams
Sandboxing
Startup time minimization

204. Other issues
Internationalization and localization
Seamless VFS integrated with Lua IO streams
Sandboxing
Startup time minimization
Portable bytecode loading

205. Code breakdown

206. Entry point

207. Entry point
Everything starts in the Elua launcher

208. Entry point
Everything starts in the Elua launcher
Lua state gets initialized

209. Entry point
Everything starts in the Elua launcher
Lua state gets initialized
Elua supports application lookup path

210. Entry point
Everything starts in the Elua launcher
Lua state gets initialized
Elua supports application lookup path
Apps get executed

211. Entry point
Everything starts in the Elua launcher
Lua state gets initialized
Elua supports application lookup path
Apps get executed
Ecore main loop is started

212. Module system

213. Module system
Elua provides a custom module system that works outside of
Lua’s

214. Module system
Elua provides a custom module system that works outside of
Lua’s
Seamless (replaces require)

215. Module system
Elua provides a custom module system that works outside of
Lua’s
Seamless (replaces require)
Modules support init/shutdown callbacks

216. Module system
Elua provides a custom module system that works outside of
Lua’s
Seamless (replaces require)
Modules support init/shutdown callbacks
Those take care of opening and closing the appropriate libs

217. Library system

218. Library system
C libraries are opened and initialized as necessary

219. Library system
C libraries are opened and initialized as necessary
Opened C libraries are cached and reference counted

220. Library system
C libraries are opened and initialized as necessary
Opened C libraries are cached and reference counted
Eolian-generated bindings use this

221. Library system
C libraries are opened and initialized as necessary
Opened C libraries are cached and reference counted
Eolian-generated bindings use this
Symbols are retrieved and bound using C FFI

222. Library system
C libraries are opened and initialized as necessary
Opened C libraries are cached and reference counted
Eolian-generated bindings use this
Symbols are retrieved and bound using C FFI
This is wrapped in high level API (no FFI exposed to apps)

223. Eina bindings

224. Eina bindings
Elua provides hand-bound APIs from Eina

225. Eina bindings
Elua provides hand-bound APIs from Eina
Containers are read only

226. Eina bindings
Elua provides hand-bound APIs from Eina
Containers are read only
Provides APIs to convert them to Lua values

227. Eina bindings
Elua provides hand-bound APIs from Eina
Containers are read only
Provides APIs to convert them to Lua values
Various modules like accessor, iterator, list, log, file etc.

228. Eina bindings
Elua provides hand-bound APIs from Eina
Containers are read only
Provides APIs to convert them to Lua values
Various modules like accessor, iterator, list, log, file etc.
Will be further expanded as necessary

229. Other modules

230. Other modules
Elua includes a benchmarking module in core

231. Other modules
Elua includes a benchmarking module in core
Also features a powerful command line argument parser

232. Other modules
Elua includes a benchmarking module in core
Also features a powerful command line argument parser
Lualian is included

233. Other modules
Elua includes a benchmarking module in core
Also features a powerful command line argument parser
Lualian is included
A custom module system implementation

234. Other modules
Elua includes a benchmarking module in core
Also features a powerful command line argument parser
Lualian is included
A custom module system implementation
Util module provides an object system, library system, string
buffer implementation and other utils

235. Conclusion

236. Conclusion
Still largely incomplete

237. Conclusion
Still largely incomplete
Getting there

238. Conclusion
Still largely incomplete
Getting there
Eo files need work

239. Conclusion
Still largely incomplete
Getting there
Eo files need work
Eolian validator needs to be fully enabled

240. Conclusion
Still largely incomplete
Getting there
Eo files need work
Eolian validator needs to be fully enabled
Lua APIs need plenty of work

241. Thank you.
Daniel Kolesa
Samsung Open Source Group
d.kolesa@osg.samsung.com
@octaforge
Lua Workshop 2015 Stockholm