The math examples look interesting, standard math notation and all. Though if I got it right, you get standard math notation with the help of TeX when viewing source code, I'm not sure about editing source code (I sure would rather write Matlab or numpy notation than use TeX in source code.)

Where are other biggish examples?

The "styles" page has the biggest bulk of interesting code that I've found in introductory pages: http://felix-lang.org/share/src/web/advocate/styles.fdoc

I guess one always wants to hear an elevator pitch of what a language does that is special relatively to relevant competition. What does Felix have that languages X and Y, its closest competitors, don't have?

Took about 5 clicks to see a decent code example. This should be priority #1 on your homepage. A simple single-page program is ideal or examples for each of the listed points.

Elixir is a good example: http://elixir-lang.org/

I have to agree. I clicked "Tutorial', and upon seeing the result thought I'd accidentally clicked something else... This is completely lacking in a user friendly quick intro to the language, what it looks like, and how "cool" (or not) it is to use.

> var a : int ; // uninitialized is ok

This seems like an odd choice when creating a new language. Most modern languages (C++11, Swift) have been introducing new declaration techniques or requiring all variables to be initialized at declaration, as this prevents a large class of bugs.

Unintialized values are fine as long as the compiler can prove that the value is never used until it is initialized. See https://is.gd/gDJCeG as an example. Try deleting the else block.

That's fine, and now that I think about it, in C++ just setting the flag to make all compiler warnings also errors, it too would prevent compilation (I think?).

IMO lack of initialization in a language should be explicit, not implicit, e.g. DLang:

  import std.array : uninitializedArray;

  int a;                                   /+ defaults to '0' +/
  int b = void;                            /+ not initialized +/
  bool[5] c;                               /+ defaults to array of 'false' +/
  auto d = uninitializedArray!(bool[])(5); /+ not initialized +/

I agree. In Swift, an uninitialized variable must be set to nil and have the properties of an optional for it to compile. Not a bad idea.

Using 'auto' in C++ forces out uninitialized variables as well.

I thought this was a new language. The repo history goes back at least as far as 2001.

I believe Felix has a special syntax to combine declaration and initialization (well, more like a shortcut; IIRC they have type inference for those cases). The code sample just shows that if you need to separate declaration and initialization, you can.

I don't know about Felix, but even the simplest C compilers I use are able to warn me when they can't verify that a variable is initialized before first use. It's not that hard. And, no, you don't have to solve the halting problem as long as you're clear what you promise to warn about. There are cases where you can trivially prove initialization or failure to initialize. Promise to get those cases right, and to warn on anything else.

Link to github repo: https://github.com/felix-lang/felix/

perhaps in particular:

https://github.com/felix-lang/felix/tree/master/demos

The README and INSTALL files are also interesting; highlighting that Felix (claims to) produces very fast code/programs and that gcc 5.1 is recommended/needed to build.

Interesting looking language - I wonder how it ends up compared to Nim (with both the C and C++ backends). I suspect there's been more focus on performance on the Felix side - but it's hard to tell. The documentation section on garbage collection (for Felix) was blank.

The mix of languages used, as evident on Github, is interesting:

OCaml 30.6% C 20.5% HTML 13.1% C++ 13.0% Python 11.2% TeX 6.7%

Wonder how that came about...

The feature list looks quite impressive:

* generates highly optimised ISO C++

* advanced resource manager organises compilation and linkage

* often runs faster than C

* glueless binding to C and C++ libraries

* lightweight threads with channels

* asynchronous network I/O

* thread safe garbage collection

* strictly statically typed

* overloading

* first order parametric polymorphism

* polymorphism with constraints

* multitype Haskell style type classes

* type classes with real semantic specification

* semantics can be checked by theorem provers

* strong functional subsystem

* pattern matching

* first class function, sum, and product types

* Tre based regexp processing built in

* bindings to Gnu GMP and Gnu GSL included

* user definabled and inline extensible grammar

* builds on all platforms

* runs on all platforms

* open source FFAU (free for any use) licence

That "free for any use" license is quite unpleasant. It's not really any different than the WTFPL. By not even including a mention of no warranty at all, you're opening yourself up to a wide variety of possible lawsuits due to "implied warranty".

The "license" doesn't even say if you can /modify/ the code. It just says you can /use/ it. You could get in some big trouble for modifying the code if the author decided to sue you over changing the code at all. In fact, it just says the software is free to use, not the code.

I might even go as far as saying that because just the software is free to use, it's no different than a proprietary program you can't modify at all, but you can see it's source.

https://news.ycombinator.com/item?id=6047560

Felix has looked interesting for I cannot remember how many decades. How many people actually use it?

You're right, I thought this was a new language. The repo history goes back at least as far as 2001. I'm struggling to see the point to this language; what does it offer over C++ directly?

Or even Go

> Or even Go

lol. Felix has Sum types, meta types, pattern matching, algebric types, unions , sets, records, channels ... Go has what? a rigid type system and channels ...

I don't mean better in terms of features but rather the get shit done this language has a community and active development kind of thing.

Why am I unable to downvote? yet others seem to have the ability to downvote my comments

There's a minimum karma required to be able to downvote.

Thanks for explaining

You cannot down vote someone's reply to your comments.

Thanks for explaining, though I meant down voting in general

Previous discussion: https://news.ycombinator.com/item?id=5007674

How to install prebuilt binaries?

I can't download pre-compiled tarballs from http://felix-lang.org/$/usr/local/lib/felix/tarballs

I followed the link Felix home -> Download -> Prebuilt Felix binaries.

I'm interested in other statically-typed languages that compile to C or C++ source (which can be then copied to some other machine and built there, or cross-compiled for it).

I've looked at Rust (which I'm writing a transpiler for), Felix, Haxe, Nim, and Native Script. Are there others?

Has anyone used it in production before?

same question, looks interesting, any more insightful info on this project?

Github is here: https://github.com/felix-lang/felix

One wonders why a project would choose a copyrighted image for its logo in this day and age. Felix currently belongs to NBCUniversal, according to Wikipedia.

"This work is in the public domain because it was published in the United States between 1923 and 1963 and although there may or may not have been a copyright notice, the copyright was not renewed." - https://en.wikipedia.org/wiki/File:Felix_the_cat.svg ... although then someone disputed that on the Wikipedia page.

An SQLITE example would have been nice.