Idea: Rewriting Love2d for Julia allows to code more interactive diagram applications and games


i think Julia could really gain from having something similar to Love2d but with Julia instead of LUA.
It is a game engine which loads a LUA file and calls LUA functions defined in their to update the application state (stored in the LUA heap), calls LUA functions to process input and calls LUA functions to do the drawing (which calls C functions in turn).

Love2d is a C++ program that kickstarts a lua program that gives back a frame callback. How it is implemented (See line 164 forward)
Then a LUA file is interpreted which handles default configuration, configuration loading, creation of callbacks and sets up the event handling/drawing loop.
From there an user redefinable loop takes over (here returned):

	if love.load then 
             love.load(love.arg.parseGameArguments(arg), arg) end

	-- We don't want the first frame's dt to 
        -- include time taken by love.load.
	if love.timer then love.timer.step() end

	local dt = 0

	-- Main loop time.
	return function()
		-- Process events.
		if love.event then
	                for name, a,b,c,d,e,f in love.event.poll() do
			  if name == "quit" then
				  if not love.quit or not love.quit() then
					  return a or 0

		-- Update dt, as we'll be passing it to update
		if love.timer then dt = love.timer.step() end

		-- Call update and draw
		if love.update then love.update(dt) end 
               -- will pass 0 if love.timer is disabled

		if and then

		    if love.draw then love.draw() end

		if love.timer then love.timer.sleep(0.001) end



Since LUA is more similar than different in programming style to Julia and both are embeddedable in C. I think it i can serve as an good inspiration to make a 2d gaming engine available.

Here are a few reasons why i think Julia would profit from such software:

  1. It is great for hackish or interactive visualization and demonstration
  2. It exposes Julias numerical performance to people working in a performance sensitive industry (Game development)
  3. It might yield insights into how the Julia GC can be modified to archive lower latency (if that is a problem)
  4. It gives a platform to ship a certain family of GUI applications in a cross platform manner
  5. It would make for a great (self) teaching tool in my experience and might motivate younger people to take a look at Julia for their early hobbyist game development

Sadly i am currently in no position to spearhead the effort myself. Although i might comeback to it in a year or so if nothing has moved in this direction.
I hope some finds that idea worthwhile and picks a good name.

Love choose to depend on the following libraries:

OpenGL 2.1+ / OpenGL ES 2+
Lua / LuaJIT / LLVM-lua

I am sure the implementation can differ from their choices and modify their interface to do more clever stuff with multiple dispatch.
If there is an library which does something similar please let me know. If you find this idea stupid or would be interested please comment.