What is Reddit's opinion of
Haxe?
From 3.5 billion Reddit comments
100 reviews of this app found across Reddit:
For people who really liked the Flash API and/or workflow, but who despise the plugin, there's always OpenFL:
It's a re-implementation of the Flash API (not the plugin/player) written in the Haxe programming language. Haxe is syntactically similar to AS3 but with a lot better features like proper strong typing, abstracts, etc.
OpenFL uses Haxe's cross-compiling feature and a bunch of cleverly written code to let you code in Haxe and export to HTML5 (JS), Mobile (C++ and/or Java), Desktop (C++), and even Flash for legacy purposes, while still using the Flash API and even SWF art content.
So I think from the coding side of thing this is where "Flash refugees" are likely to go and kind of gives us the best of both worlds. Migrate legacy codebases over, keep the best bits, ditch the Flash player long-term, and end users get stuff in HTML5 or native, and if you absolutely still have to export to flash in the short-term, you can.
We built a custom engine for The Masterplan, using Haxe. Recently had the post-mortem for the game, and we all agreed we were still happy with the decision. Why?
- Whenever we encountered a serious problem with the underlying tech, we could drill down as deep as needed to fix it. With most commercial engines, you hit a wall at a certain point, and will need support from the company making it.
- Help was very readily available from the Haxe open source community. With commercial vendors, that level of support would've costed some serious $$ - now we just had to be active and make ourselves useful in figuring out the issue.
- All engines have a "sweet spot" for what kind of games they're best for, and turns out for a top-down tactical heisting game it really can be faster to build your own instead of adapting an existing engine.
Having said that, my recommendation to new developers is to go with Unity. The team behind Masterplan has built engines before, and we've probably learned a couple of things on the way.
Secondly, I strongly advocate at least using a framework that allows you to get crap on the screen on day one. You need to be working on the game from the get go.
Well games are certainly easier to do cross platform, because GUI is completely custom. You can write it now in C++ and it's basically portable between iOS, Android and Microsoft (I think). Or you can use RoboVM or Haxe.
I've been programming in Haxe since 2006.
Haxe was the first language to support the actionscript 3 virtual machine. That's right, it was possible to write flash 9 apps before Adobe released actionscript 3. And it has always been faster than AS3 ever was, ever since.
Haxe has built-in dead code elimination and many performance features, like abstract types: http://haxe.org/manual/types-abstract.html
Since most targets are source targets (actually I believe only SWF and Neko are bytecode based targets), the performance is as good as writing the code in the source target. There are usually no wrappers involved or required.
The past few years, the javascript backend has been greatly modernized and improved. As long as you don't use reflection, the produced code can easily be even further optimized by the google closure compiler "advanced compilation" mode. Also as it turns out, the JS class structures generated by the Haxe compiler are pretty much the perfect match for V8's JIT.
The original use case was building web games, where performance is important (slow runtimes...). To see some proof, you might want to check this out: http://www.openfl.org/showcase/
Nicolas Canasse (of Shiro games) is kind of a genius. He invented the Haxe programming language (a language which compiles to other programming languages, including C++, C#, Javascript, Python, etc.) which powers a lot of other frameworks such as Kha, OpenFL, HEAPS, Flambe, Luxe, etc. It also powers HaxeFlixel, HaxePunk, and Stencyl.
A lot of big companies are using Haxe -- Tivo uses it for their set-top boxes, Prezi uses it, Mozilla supports it, and a decent number of console developers are using it and OpenFL to replace Scaleform, and it's starting to make enroads in lots of other places, too. (I for instance am using it to make Defender's Quest II).
So it's not a run-of-the-mill situation where some little indie company is using in-house tech. A comparable example would be, say, a game company that Anders Hjelsberg (C# inventor) works at using C#.
Haxe is remarkably powerful --- right now I'm working on a project getting it to run on consoles. Got a couple of WiiU demos running so far and we should have Xbox One and PS4/Vita up shortly :)
If anyone interested. "Hello World" in haXe compiles out to 325 lines of code. gist: https://gist.github.com/1277584
it includes code only for parts of standard library that is used.
edit: fixed link
It can't be worse than this sack of shit.
> "Want to develop a program and convert it to any language you want? We forgot to mention though you'll be locked into using a language as soon as you develop anything beyond 'Hello World'. But it could be cross language."
Here's a short list of companies using Haxe:
- Tivo
- Prezi
- Motion Twin
- Nickelodean
- Disney
- BBC
- Mattel
- Coca-Cola
- Shiro games
- Hasbro
- Toyota
- Massive
- area9
- stencyl
Not sure if it has everything you're looking for, but Haxe NME has a surprising amount of cross compatibility. Can compile the same code into a flash swf, windows executable, iphone app, android apk, html canvas, and a few more. Definitely worth at least looking into.
EDIT links for the lazy:
Well, all the existing AS3 libraries (swf/swc) can be used as externs within haXe already, provided you are only targetting swf. You can also produce swc as well.
From there, you might try mixing in javascript/php, and using haXe remoting to communicate consistently typed objects seamlessly between the three targets. http://haxe.org/doc/remoting
There aren't a large number of haXe libraries yet, mainly because it is difficult to generalize and optimize functionality across all the targets. (as3 does not have a dom, js does not have the as3 api).
Think of haXe as a way to consistently organize typing and basic object structure across all the targets. Then, for each target, use platform specific libraries and api's to handle platform specific functionality. (JS dom manipulations with jquery, papervision 3d for flash, etc.)
Haxe + the Kha framework
See the mailing list on Google Groups for help with Haxe.
Personally, I just want to see a track record of successful production use. That some lumbering corporate likes it doesn't excite me at all. I suspect such pages are just there mainly to reassure non-technical decision makers that they're not fucking up.
You're right though, I found http://haxe.org/com/projects and http://haxe.org/com/ide much better demonstrations of the languages use and maturity.
By the way, you should definitely give haXe a try. The language is almost the same as AS3, but it’s improved in many ways. Besides, the compiler is orders of magnitude faster and less memory hungry than Flex.
Have you checked Haxe? Haxe transpiles to several languages like C++, C#, Lua and JavaScript, among others.
Performance will not be a problem. All of the major javascript engines are pretty fast these days (sometimes within a few factors of the speed of compile c++ code!), especially for a 2D tile-based game. Even if you're doing realtime physics, you still have to push it quite far before it crumbles.
The performance issue m4rx mentioned sounds like an issue with Phaser.io
Regarding javascript as a game dev language choice, overall I think it's ideal for what you want to work on, but I'd recommend skipping es5 (the current dominant version) and start working with es6. This is because es5 lacks features like module loading (ie you can't actually import code from other files by by default!), and a well-defined class system. This means once your project starts to grow, it can become difficult to manage.
Ecosystem-wise, javascript's community is vast, so you'll have no trouble finding libraries and solutions to issues.
It's worth checking out haxe, which compiles to javascript but was built with game development in mind. It has autocomplete built into the compiler, this is a killer feature for me and a massive help at reducing the learning curve.
Just putting this out there, the WebGL option is currently garbage. Build sizes, performance, and compatibility all suck. It will be years before it's viable outside of tech demos.
Telling users to change browsers or fuck with their Chrome settings is also stupid, no normal user will do that, they'll just not play your game.
If you're building web games with Unity you should move onto a different engine for a couple years. I suggest looking into Haxe and some of the game engines available for it:
https://github.com/aduros/flambe
It's an easy and powerful language, and you can build it to most of the same platforms as Unity. For the web you can use both Flash and HTML 5 so that you can target a larger user base than you ever could with Unity. You can even have mobile web games that run well.
Building Haxe games is harder than Unity, but you can make web games that everyone will be capable of playing.
Its very cross platform.
I believe they made their own language and allow it to compile to a bunch of other languages, see:
- http://haxe.org/documentation/introduction/language-introduction.html
- http://haxe.org/documentation/introduction/compiler-targets.html
Actually pretty cool, except you'd have to learn their language first.
You could try http://haxe.org : you could use it for pretty much whatever you want (desktop, mobile, server side and client side web) even though i'm using it only for making games with the http://haxenme.org/ framework. If i remember right it's been made from the guy who made an open source compiler for AS3 and the syntax is almost identical.
If you are not afraid of a little hassle, I suggest the following:
- For compiler/SDK, use haXe. It beat Adobe's compiler (mxmlc) hands down both in feature (optimizing compiler, type inference, macro, etc) and speed.
- For IDE if you use Windows based OS, FlashDevelop. But if you are on other OS (Mac or Linux) you can try FDT (Commercial) which recently have a haXe plugin added (still Beta) or Eclihx, or if you feel adventurous you can try vim or emacs with haXe plugin (check the webiste).
- For Engine (in case you want one) there is a haXe port of Push Button Engine called HydraX (IIRC). Or if you want 3D you can try Sandy3D or Away3D Lite both have haXe version. Or again if you feel adventurous you can develop for molehill and use HxSL (haXe Shader Language) :D.
Haxe with Haxeflixel. Haxe is a great language with some fantastic features, Haxeflixel is a solid 2d game engine with built in tilemap functionality that's built on top of openFL, meaning it exports to html5, flash, windows, android, ios and more. The workflow suit me well and it's totally open source and free.
Haxe compiles to JavaScript, gives you strict types, and proper OO syntax...
Dart also compiles to JavaScript.
I'm a fairly ignorant coder when it comes to classes, as I stick to using factories, so I am a bit in the dark when it comes to their advantage (it always seemed like a bad idea for me to use a structure which changed in one place, would propagate those changes to the whole app--the negative side effect just scared me off)
Hi, this is the language author, thanks for the interesting analysis :) Incidentally I am in fact a "she".
"Everything-as-a-function is a concept that dates from the 1930s"
Rather than lambda calculus, the point I am taking as inspiration is the calculus of logical combinators (Curry did some stuff with this) which is sort of like point-free lambda calculus. If things like numbers have function semantics, then I can think of "3" as just another combinator.
"A good resource to start from would be Types And Programming Languages (TAPL)."
I'm up to chapter 15 so far :)
"A good idea would be to implement the language on top of Node.js or Lua's JIT instead of rolling his own, guaranteed-to-be slow interpreter (I hear Node.js can interoperate with C++!)."
The interpreter is incredibly slow. The next step is to try to set up an ahead-of-time compiler of some sort (and since I have the interpreter as a bootstrap I can write the compiler in Emily…). I want to be able to build on top of both Javascript and C++ libraries, so I am going to try to do this in such a way there is more than one target. I am considering trying to start off by generating Haxe ASTs because if I can do that I will get transpilation to several other languages for free.
"Also, there seem to be a conflation of run-time and static types. What he describes would be blatantly undecidable as a static system, but if understood as a runtime system, merely another way of saying 'assertions'."
The intent is to collapse undecidable runtime assertions and decidable static types into a single construct from the user's perspective, then have the compiler tease apart which "types" are actual honest-to-goodness types and which "types" just become runtime asserts. I am not yet certain how feasible this idea is.
- You can try it online: Simple Hello world (Click on Build & Run and then you can inspect the generated JavaScript). It always pure JS. If projects grew larger you get a slight overhead for some Haxe functionality that is not supported by JS.
- Same for Haxe. Browser APIs are included, for libraries you could write externs if no one had used this library before. There also was project for generating extern out of TypeScripts Definitly Typed definitions.
- I use Sublime, but from what I heard Atom support should be good to.
- Sadly, this is true
- Haxe has been arround for a very long time
- You can buy support through the Haxe foundation
- It's open source, so if you like you can continue development even in the rare case it will be discontinued.
- You can edit the generated JS that is emitted by Haxe compiler as good as you can edit the JS generated by the TypeScript compiler.
You can program in haXe, which is very similar to AS3, and improves upon it in many ways. Its compiler can target a bunch of different platforms, and it is also much more friendly on resources than Adobe’s.
I started learning and using Unity since last week and have never encountered a problem without an answer somewhere ready to be returned on the first page by Google. So I think it's beginner friendly but if I can choose I would still prefer using an 2D exclusive engine to make 2D games, Unity seems to complicate things that are very simple in other 2D exclusive engines. Also there are a lot of jobs available for Unity (reason why I'm learning it).
This may be off topic a little but I would love to tell you about Haxe and HaxeFlixel. They are easy to learn, pleasant to use and Haxe is a very powerful (meta) language that can target Java and Python so it can also be useful for you outside of game develoment. Haxe also has plugins / libraries for other engines like Unreal, Unity, Phaser, Love2D, etc so you can use this same language for multiple engines. They are not popular so documents are currently lacking but it's getting better everyday now.
I'm the author of the Haxe Lua target. It's still very new, but I believe it can help Lua grow, and keep long time Lua folks from jumping ship to a completely different ecosystem.
Haxe is in many senses a very different language than Lua, but it addresses many of the authors complaints:
- LuaJIT is in permanent maintenance mode : Haxe can't really solve this one, but it does give you the option of adding new language features on top of a stalled target.
- Lua version fragmentation : Haxe Lua abstracts away some differences between 5.2, 5.3, and LuaJit. 5.3 is only supported with backwards compatibility support for now though.
- JavaScript's ecosystem is awesome : You can use the javascript ecosystem with Haxe as well, as it has a very mature js target.
- Lua Coroutines are no longer a monopoly : Haxe has several asynchronous options. These options include promises, and theses features abstract over whatever asynchronous options are available on a given platform.
- Type annotations FTW : With Haxe you get three different type systems, each more powerful than type annotations : OOP, structural typing, ADT/pattern matching (in addition to Dynamic/runtime typing, if you don't want typing for some reason).
I'm not going to pretend that the Haxe and Lua languages are related, but I think Haxe is a very promising way of building more sophisticated Lua based applications. E.g., It is now possible to use one language to target an nginx/lua, redis/lua, and javascript stack. In fact, that's what I'm going to try and work on in the near future here.
In C++, I found the mapbox variant class reasonably pleasant to use. Not as nice as in ML/Ocaml/Haxe/Haskell/other languages but after I added a pattern matching function, I was able to write code like this:
variant<A, B, C> obj; match(obj, [&](const A& a) { ... }, [&](const C& c) { ... } );
Haxe now has HaxeDevelop for Windows, which is a first class editor for that platform. There's also surprisingly strong plugins for visual studio, sublime text, and vim, among others (full disclosure, I'm also the author of the main vim plugin). http://haxe.org/documentation/introduction/editors-and-ides.html
In fact, one reason to target Lua was that it was one of the few remaining gaps for providing IDE script/code. I personally wanted to use lua for vim/neovim. There's an existing toolkit for providing basic universal IDE support here: https://github.com/snowkit/tides
Hi!
I'm also looking to connect with gamedev-interested people
I'm in Plymouth (UK) which has a very small tech scene (and an even smaller game dev community!)
I currently do freelance interactive graphics work, WebGL for documentary sites, adverts, etc, but trying to get into game dev in the long term
Language-wise I usually use things like haxe and target the web because it's where I'm most productive (and where I see the most business potential!).
I'm up for a chat if you are
pm-ing you my skype & steam details
If you want native iOS and also being able to compile for Android you can use Haxe language with OpenFL framework HaxeUI for UI. Language looks like actionscript and it can be also compiled to JS and C++. OpenFL also supports Windows, linux, Windows phone and HTML5. It is mostly used for games but with HaxeUI it can be also used for applications.
A question mark can signify a "ternary if" expression: https://en.wikipedia.org/wiki/%3F:
Or, it can signify an optional function parameter: http://haxe.org/manual/types-function-optional-arguments.html
Wish this 1-paragraph explainer of "What is Kha" was linked at the beginning of the slides, but it's not, so I'm putting it here as a supplement: http://tech.ktxsoftware.com/kha/
Also here's an explainer for Haxe itself (the programming language Kha is built on): http://haxe.org/
haxe is worth a look if you want something different: http://haxe.org/use-cases/games/
and if you want something really different i'd recommend racket: http://docs.racket-lang.org/games/index.html?q=%s
The language Haxe can be compiled to both PHP and Javascript. ;)
OCaml can also be compiled to Javascript using <code>js_of_ocaml</code> (that's what Facebook used to build their browser IDE for Hacklang), but there's no (reasonable) web-framework for this language. Yet.
The community edition is always free. Also, it looks like Haxe may now be supported in the community edition following this tutorial
For an alternative, you can look into the haxe plugin for sublime text. Sublime Text isn't free, but it has an unlimited free trial period, so you can see if it is worth it to you.
While I've not used it myself, you could look at haxe, a nice looking typed ecma/java-like language that compiles to js, flash, C++ and others. The idea being you work in one language, but can output the same code to multiple targets. (So maybe you could decide later, release to multiple, or just make js nice and strictly-typed)
Might not feasible for the js route if you've really had to optimise stuff, as not sure how efficient its output is, but maybe worth a thought.
Anyone interested in larger js projects should check out haxe: http://haxe.org/doc/intro
I've been working with it for years, it's been great. It's statically typed, with type inference, and a super fast compiler. The compiler even helps you with completions and package names, rather than just tell you how your typing is wrong.
I use Haxe in FlashDevelop on Virtualbox running Windows on my Linux (Peppermint) netbook.
Haxe targets just about everything, so I can test my game in Linux or Windows. You can also use Eclipse in linux instead of FlashDevelop, but the latter seems to be more commonly used for Haxe, so I figured it would be easier to set up and learn by going with the most common approach. I may give it a shot in Eclipse later on.
It's only been a couple months so far and I'm loving Haxe.
If you want to make a relatively straightforward step to transition out, try the haXe, NME, and FlashDevelop combo. You'll still be able to work towards the Flash target for the time being, but if/when you want to change the transition will be smooth.
Since Adobe's mobile announcement, haXe has picked up a lot of attention from AS3 devs. You'll be in good company.
I second haXe i made most of my games using haXe. See some projects built with haXe and the community is awesome!
The language is haXe. It uses the Flash Player 9 target and APIs so it currently is for Flash Player 9 (or later). At some point later (after the game is online) i might try the hxcpp target which converts the code to C++ and uses GCC to compile it in order to make a standalone version. It'll need some modifications and a simple layer (possibly SDL-based) for the functionality that currently Flash provides (i'm only using a small subset - bitmaps and input - so it shouldn't be hard).
- list comprehensions
- Python properties
- Anything in SQLAlchemy
- The web framework http://naga.re was well ahead of it's time... at that time. Now there are many 100% Python frameworks that save you from writing HTML/CSS/JS
- The Python language is simple and elegant. That is the real Genius. perhaps it could learn from Nim or Haxe but that would it make it the best when Python is the second best language for almost anything!
If you guys haven't heard already, you should all check out Haxe and OpenFL. Haxe uses a very similar syntax as AS3 and can deploy to several platforms, while openFL is a library for Haxe that's meant to bring the AS3 api to haxe. I absolutely love this, as I can develop games based on the knowledge that I gained while working on flash without the compromise of flash.
The OpenFL platform is a reimplementation of the Flash API for the Haxe language (a near-superset of Actionscript). It can target javascript/html5 or can compile to a c++ native applications for pretty much any platform you can think of
Some other languages have features that are similar, but weaker and uglier (and are maybe meant for a different purpose anyway). For example Haxe lets you define a type that exists only at compile time as an abstraction over a runtime type. The problem with using that for things like units and conversions is it's not generalized, you end up writing a <u>lot</u> of boilerplate code, and you don't get to write "meters per second" as just m/s
Papers Please is written with Haxe so I guess that would work. Simple to learn language if you have C++ experience. It compiles natively to most platforms if I remember correctly. You could also look into HaxeFlixel which is built on top of Haxe but has more tools for game making in 2D.
As said Cocos2d-x has good UI support (personally I wouldn't use it, did one project and the documentation is horrendous imo).
Libgdx is great and what I'm currently using but I've been thinking about HaxeFlixel also.
Are you following the instructions on any of these sites?
http://www.openfl.org/download/
http://haxeflixel.com/download/
Once you have haxe itself installed, and you can recognize haxelib on the command line, "haxelib install flixel" should fetch haxeflixel and all its dependencies (including lime & openfl and the rest).
If you want to use an in-development version of those libraries (ie from git) that's a different story.
My vote would be for Haxe because I feel like it's a good higher level language. Haxe also has HaxeFlixel which is a super good and easy game development framework. But honestly it's what ever you feel comfortable with and enjoy so maybe try a few out and see what you like. I will say it's good to learn some basics of programming and the fundamentals of OOP which can be used in any language. The best thing you can do is just dive head first into it.
On C++ strings: Well there you go. It's possible. It would still be nice if there was a dedicated function for that. It could even be inlined and there'd be no performance loss at runtime, but at least there'd be a guaranteed search result for "string starts with".
On properties: I think you might have misunderstood what I meant. They're called properties in Haxe. Here are the official docs, but to summarize, if thing.property is a property, then doSomething(thing.property) is equivalent to doSomething(thing.get_property()) and thing.property = 4 is equivalent to thing.set_property(4), and what I don't understand is why anyone still explicitly uses getters and setters when this is available instead. In Haxe you can also enable properties for getting but not setting or vice versa, and it's implemented in the same syntax used to make a constant or (because consistency) a write-only variable.
I'm just poking around here and I've got Rust, Boo, C#, Dart, and Java lined up to look at. I don't mean to say that I've never done anything with any of these before, but that I haven't in a while and it might be good to try them again. (Actually, I haven't done any Rust or Dart before, but I have done a bit of Java and C# and the tiniest possible amount of Boo.) Anything else to say on those five?
No problem! The core audio loop in Flash is pretty performant. Especially if you use Haxe which gives you easy access to faster array / memory primitives (though it's been a couple of years since I did it I don't know how the landscape has changed).
If you are using HTML5 for your visuals, you need to rely on the ExternalInterface, message passing between js and as which had an additional latency last I tried. It never worked as robust as I'd like it to be.
Also Flash doesn't have primitives like filters and such so you have to program them from scratch and they will be expensive. In webaudio if you use the native filters for instance, they are implemented in native code so it's a lot faster. If you are relying on scriptprocessors in js though, the performance difference might be negligible.
And with Flash, you'll need to code your audio loop from scratch in native code for mobile if you are doing any serious processing.
That's not really answering your question but haxe compiles to PHP. It looks like PHP but with type inference and other nice stuff. It also compiles to JavaScript, C, C++, Python, Java, etc ...
I've used it a bit and find it quite pleasant even though I eventually gave up.
Ah, you're looking at the old docs then. The new ones don't mention globals.
In any case, by targeting Flash 8 you will have to use the flash8 platform-specific API of the Haxe standard library. Thus, all of your flash.Lib calls should be changed to flash8.Lib before compiling.
I suggest you consider switching to a more recent Flash version if the issues persist.
Hey! I used an engine called HaxeFlixel. It uses a language called Haxe that allows you to target many platforms(flash, web, desktop, console, etc). Haxe is very similar to Actionscript, which is what is used to program flash games(and based on ECMAScript which makes them pretty much sibblings with Javascript).
The games on my site are using the flash plugin, not Javascript. It's a slightly antiquated technology that simply won't die and happens to work really well for web games.
And yes you can! You can beat all 20 levels!
Project Eclipse
This game is an intense action-platformer with a heavy emphasis on boss battles. Each stage of the game will task the player to defeat one gigantic, hardy, viscous monster in an intense and lengthy battle that can spawn multiple arenas. Bosses move and attack dynamically and adapt to how the player fights, meaning battles are less about pattern memorization and more about mastering the simple but deep gameplay mechanics.
It's being made in Haxe, a neat language that can compile natively to multiple platforms, most notably Flash (for playing previews in a browser) and C++/desktop (for optimal performance).
I'd like feedback on the game's feel, controls, difficulty, and if the "tutorial" is effective enough in showing the player what to do. In this state the game has poor graphics and no sound, which hasn't been focused on yet in development.
Controls:
Z - Jump
X - Attack
SHIFT - Dodge
(hold) SHIFT - Run
Web Preview. Just press ENTER when the game loads to start. There are some options left over from testing which can be ignored.
Note: The game is in a very early state. Only one bass battle is "complete". The art is currently in transition between lame placeholder art and the actual art, so right now you just fight a block that jumps around.
There's still a lot of work to do, but I hope people will enjoy what's been made so far. Thanks!
Ruby itself is a dependency. The compilers will turn it into an executable for those environments that won't require any dependencies to be installed.
I know this is the ruby subreddit, but I figure most of us use multiple languages, but anyone interested in getting all 'cross-platform on this bitch' should check out haxe (http://haxe.org/). It's a little more like java than ruby, but its pretty freaking awesome.
Hello and thanks! The engine is built on top of Haxe and OpenFL. The asset watching / live update logic is pretty platform / language agnostic though. Basically there's a process that watches a specific folder for changes. Parts of the engine / game that are interested in changes then register listeners for when changes to the assets happen. For example, when someone loads and displays a sprite, the sprite manager or what have you, registers a listener for the path to the sprite / image / spritesheet. If that listener gets called, the sprite manager knows that the asset has either been modified or deleted. If it has been modified then it just loads and swaps the graphics for the sprite.
I think we might do an in depth technical blog post / video about how this stuff is set up in our engine.
Here's a succesful instance of a game co-op I found back when I did my own research on the topic:
http://motion-twin.com/press
It's a commercial game studio that's democratically run and worker-owned.
Merely one of the many possible forms a game co-op could take, but a good start and an example of what's possible.
The really cool "Haxe" open source game engine was developed there. http://haxe.org/
I already have all the cross platform stuff I need (http://haxe.org/). The programming was never the bottleneck with succeeding at making a living from indie games anyway, and even if it was we're already well served when it comes to multiplatform frameworks/engines.
I don't know if Ouya will live up to expectation, but I hope it would.
At any rate neither of these examples are particularly exciting for me.
Someone's been working on d-objc.
You might also look at haxe, which appears to work on iphone.
You can bind haXe functions and classes and expose it to Orbit. haXe does have reflection.
>what's the use of using it as scripting language when programming haXe games?
To allow end users to mod the games, or maybe to use it as a data format for levels. For instance, let's say you've built the game, which can load levels. You can allow designers to script special events within the levels. Or maybe procedurally generate stuff. And you don't need to recompile your source code.
Of course, if you target Flash, it's a little bit more troublesome (but still possible -- if the script files are embedded in the swf, users can't modify it, but you can make the scripts load from a URL).
If you target C++, your end users could modify the script files and create mods.
If I was to start a new project today, I would seriously consider haxe (again). same code written in a powerful language, easily published to AS3, C++ or even js in parallel with (what seems like) nice performance. Check it out!
It's especially strange how it's nearly impossible to find out who's behind this project.
Someone has entered it on the haXe wiki page about projects using haXe on the 7th of April. Has a web site with similar… ahem… aesthetics and talking about Circus Now too!
Don't call it names just because it looks strange!
I program in haxe, a multi-platform language that compiles to flash bytecode but can also be used to compile native desktop & iOS apps.
Knowledge of flash (either via as3 or haxe) is a big plus but not a strict requirement.
Knowledge of iOS development is also a plus but not a requirement.
Motion Twin did a similar thing with haXe (which, like Fantom, is a meta-language that compiles to Flash, JavaScript, C++, PHP and hopefully soon Java and C#).
That sounds like there is no documentation, which isnt true. There is actually quite some documentation about the language on http://haxe.org/manual and usage examples on http://code.haxe.org Many popular libraries have their own sites with documentation too. So yeah for a opensource project I would say its actually reasonable documented.
Also if you target a certain target you can get away with its native docs. like JavaScript for example you can reference MDN since the interface is kinda the same (well its typed ofcourse, but thanks to type inference some examples are copy/pastable)
Check out Haxe. It has a syntax similar to Dart; it is automatically transpiled to other languages (mainly C++ and Javascript) and then compiled natively for your target platform; targets are Windows/Macosx/Linux, iOS/Android, html5 and several consoles. There are: basic libraries like Lime and Kha that abstract away the platforms differencies; bindings for various C libs (opengl included); and a great numer of existing game engines - that means it should't be so difficult making a new one ;)
Games as different as Papers, Please and Northgard were made using Haxe.
My personal opinion is that you have Python - a beautiful language that can call libraries from almost any other language. The complement to that is Haxe, a fine language that produces code for many other languages/platforms. With the two, you can call almost anything or produce code that can be called by almost anything. An awesome set of tools.
GML is a loosely typed and fairly "permissive" language, akin to JavaScript. You don't need to explicitly declare variables for objects; you get away with doing things slightly (or not so slightly) oddly. On the downside, compile-time checking and auto-completion can't do as much.
C# is a strongly typed language. You have to declare variables before you use them; "stepping out of line" usually yields compile-time errors, for better or worse. As the result, auto-completion and compile-time checking are better, but you pay for that by having to write more code to begin with.
The two languages serve almost-opposite purposes - one is good for quickly prototyping games, other is good for writing complex systems and algorithms.
There's always an option of keeping your complex systems inside native extensions written in C# though.
I personally also periodically poke with compiling Haxe to GameMaker (granting compile-time checks and auto-completion while having regular GML code as result), but it's not known if\when this'll be publicly available.
You could also take a look at http://haxe.org/ and one of it's many frameworks. With haxe you can ouput your game to different devices but know that for building a Mac app you will need a Mac or MacOS running in a virtual machine because you need to use XCode to compile your Mac project. For HTML5 and Flash you can always easily export and have ready to go files
The openfl framework for haxe is quite popular and gives you an API that is similar to Flash and you could combine it with a game framework like haxeflixel to get an API that helps you to build games. The game "Papers Please" was build with openfl, so you could take a look at it's minimum system requirements to get a sense of how much hardware power you would need for a game like that.
There is also kha for haxe: https://github.com/KTXSoftware/Kha, which has a lower level api (something like opengl but not as low level as opengl ;) ) and has a big focus on performance. Because the focus is on performance it does have a small but focused API where you gonna have to do some more work, compared to openfl + haxeflixel, to create a game. Kha also has his own code editor called Kode Studio which is based on Visual Studio Code: https://github.com/KTXSoftware/KodeStudio
Building with kha will give you ready to use HTML5 or Flash files but for stuff like Windows you will get a Visual Studio Project which you then have to compile in Visual Studio to get an .exe. Similar goes for openfl where you need Visual Studio C++ to build for windows for example.
I've been into Rust as well lately, I was planning to also read the annotated source code of Lua 5, have ever checked that out?
I think one compiler in particular grabbed my attention in the past a couple of months and that is Haxe, what do you think about this one?
Maybe we could add a glossary, or have those words be links to the respective homepages? Would that help?
Haxe is a light-weight game toolkit that simplifies some tasks when making certain types of games.
Lua is a simple programming language, often used to script basic functionality inside of a game engine.
If you already know another programming language and understand basic concepts, this provides a nice quick introduction to the language and can be followed by the official manual.
If you don't, then I'd recommend to rethink your decision to start with haxe as your first programming language since it actually only transcompiles to numerous other languages and getting it to work and to understand the process (not talking about the possible bugs and error messages such a process can include) might be really confusing for a complete beginner.
Correct me if I'm wrong, but it sounds to me like you're looking for the "Rest Argument" section of the Haxe manual. It specifies a way to define a macro function with an array of expressions as one of its parameters, making it possible to pass an arbitrary number of arguments when calling the function.
Depending on what you want to use it for, http://haxe.org/ might work for you.
There are some other options available as well: http://ntt.cc/2010/05/14/11-open-source-ide-tools-compilers-for-adobe-flash.html
You must trying OpenFL. Same syntax than AS3 but with Haxe in background. You'll be able to build an app for html5, ios, android and many others plateforms. Trust me, i was a Flash developper and i migrate to this plateform. It's so magic !
I recommend looking into OpenFL. It's replication of the flash graphics API so you can use it on any platform (html5 with canvas or webgl, native mobiles using C++ or Java with OpenGL). You can still use assets created in the flash creative suit and still export swfs. It can certainly ease up the transition into a flashless world!
OpenFL uses haxe, originally designed as alternative compiler for as3 its since become it's own language and now can be used as a cross-language compiler, outputting javascript for html5 or C++ and Java for mobile (it actually supports compiling to python, java, php, C# and as3!).
There's a bunch of tools out there to easily port existing as3 to haxe, it's a fairly smooth process since the languages are so similar
Flash doesn't deserve the criticisms it's getting. It's an old technology, but it was way ahead of its time when it was released, and ecmascript, svg, etc. are only just now catching up. Its security track record is equivalent or better than most other web technologies over the last decade.
I would strongly suggest anybody concerned about what they're going to do with flash/as3 skills to check out Haxe: http://haxe.org/
You get a faster compiler and faster executing swf code, as well as the ability to target javascript/cpp/java/c#/php/python. Haxe is strongly influenced by as3/ecmascript, the flash graphics api is available cross platform via OpenFL, and the language is very similar to as3.
Just as an example of what I mean: http://haxe.org/manual/target-details.html There is no documentation for Neko, C# or Java. Also, one particular problem I had finding documentation for was how to export your project as a javascript library.
Haxe has something (which I've never used or needed, honestly) in addition to the standard visibility keywords and C#-ish properties which lets you get silly with access control. You might(?) even be able to do things like have a property with a setter that's totally private except one other class is allowed to set it
Have a look at Haxe. It's similar to AS3, but has a number of very convenient new features, including a transpiler that can generate code for a wide range of popular targets.
If you're looking to escape Flash, have a look at Haxe. It deploys to nearly everything, and: "The Haxe programming language is easy to learn if you are familiar already with either Java, C++, PHP, AS3 or similar object oriented languages."
Also, if you want to leverage experience with Flash: OpenFL "A framework built on Haxe that provides the Flash API on several mobile platforms, and tooling to help compile and test your app on each platform."
There's another language that I'm pretty sure isn't functional, that supports ADTs: Haxe. I don't know if it's "popular" but then again I don't really know what Julia is (though I've heard the name).
you might find haxe interesting - it's not in the ML family, but it has clear ML influences, and a C like syntax. also it compiles to a bunch of different targets, including desktop, web and mobile.
If you like AS3 and the production flow then you should look into HaXe I found it to be incredibly powerful and deploys natively on the various supported hardware, unlike Flash / Air which dummies crossplatform support by using it's own runtime.
I think part of the problem here is that the author may have accidentally pulled a small bait-and-switch in his post. Maybe there is no one language that is both great for learning about programming/computer science and that can also meet the other criteria that were used to knock Python off the list. After all, most of us do end up learning and using multiple programming languages.
The only thing that I can think of that might meet both requirements is Haxe. A "real" language and cross platform, but I guess it suffers also in that you do have to choose your libraries to do things like graphics.
What about Haxe? It's based on ECMAScript, is easy to use, supports game development, and supports multiple platform targets. It apparently even has a Python bridge and support for several editors / IDEs. It seems like a strong choice.
What about Haxe? It's based on ECMAScript, is easy to use, supports game development, and supports multiple platform targets. It apparently even has a Python bridge and support for several editors / IDEs. It seems like a strong choice.
I believe Mod Pi in a video explained that they're not explicitly writing a C++ client, but are making a general purpose code base that will then be compiled into any language from there.
Reminds me of Haxe.
This should allow them to support the Java Client, HTML5 Client and any other language client they wish. It will be cool if it works!
Its actually brilliant because the best thing about it is that it compiles into other languages such as c++, java, javascript, c#, and some other but have forgotten which (too tired right now T_T).
Its very easy to get into aswell, especially for 2d game development for the web. WebGL and flash is supported through Lime and OpenFL.
Another thing is that installing these 3rd party libraries is very easy to do too. iirc Lime can be installed as simply as calling 'haxelib install lime' in the command line.
If it's gonna be a learning experience anyway, consider making the jump to Haxe and HaxeFlixel, the Haxe port of the popular Flixel engine.
Haxe as a language is really similar to ActionScript 3 and Flixel makes developing games, especially "simpler" ones like platformers, a breeze. The advantage of using HaxeFlixel over "vanilla" Flixel is that you can natively deploy to all major Desktop and Mobile OSes, including Flash, although some features, especially rendering related ones, are Flash exclusive still.
Of course all of this assumes you are talking about AS3. If you have AS2 experience, you're gonna have to start slightly lower by getting into object-oriented programming first, which is gonna be essential for any modern game development.
You should give Haxe a try. It's a relatively new language that works almost exactly like AS3 but is also able to compile natively to flash, windows executables, android, and other platforms. It's also very easy to integrate with OpenFL, which others in this thread have mentioned.
Being new, Haxe still has some kinks to work out (like how it's supposed to be able to compile html5 but it doesn't work very well), but it seems like a good direction to go in for former AS3 devs.
Agreed. Though I'm not sure that's the best yardstick, because any language that's a drop-in replacement for JS must also contain all the stupidity of JS, so we'll never get much progress that way. The next best thing is being able to easily interface with JS so you can rewrite the code piece by piece, and haXe has a couple ways to do that.
So two languages implemented in OCaml with nearly the same name: Haxe, and Hack. To add to the confusion, you could have Hack code running on HHVM, and also Haxe targeting php running on it.
I had never heard of it before your post, but right there on their homepage are the pictures of two phones and two tablets, so yeah, I think it is possible to use it for mobile development.
Maybe find a C# supported development library and experiment with it? There's haxe, SFML, SDL...
I think the best advice I can give about learning is think of a game concept and just make it. Maybe take part in some game jams or anything that takes you out of your comfort zone?
I think a good way to gain skills needed to make a 2d game is to make a 2d game, learning as it comes.