Hope to bring Kotlin to the Elements family

Kotlin is really a plesant language, and I don’t think it’s “Swift on Android”, especially when Swift 5 introduced so much mess.

Having Kotlin could really be a game changer. I understand C# and VB.Net are two quite different dialects on .Net you added for different purpose (especially MS does not like VB.Net, you bring a future and so much possibility for this language). Having JAVA/Kotlin together may seem some duplicated, but Jetbrain has not plan to bring Kotlin to .Net.

To be frankly, I would rather Elements has Oxygene/C#/Kotlin/VB.Net/GO, for Swift, we can forget it, let it keeps on Mac/iOS only, if Apple still likes it. For Java language, it’s nice to have.


1 Like

Agreed. in hindsight, had we known what an utter mess Swift (the language; let’s not get me started on the rest ;)) would turn into, Kotlin would have been the better choice, than Swift. But many people rely on our Siwft now, so we’re not getting rid of it (as much as it sometimes pains me ;).

We might still add it at some point in the future, but i cannot say we have any concrete plans to announce at this time. We just spent a big effort on adding Mercury, less than a year ago, and even while that’s somewhat orthogonal to Kotlin, its probably a good idea to let that one settle in before we startt on language number 7 (or actually 8, teaser ;).

I will bring it back up for internal discussion/prioritization, though.


1 Like

Are you going to do a functional one ?

Not currently planned, although we had a “f(Oxy)”, a “functional Oxygene” on the drawing board quite a while back. Personally, Functional languages give me a headache, going all the way back to (iirc) ML at university ;). But i’ll see what the rest of the team thinks.

Right now Swift is really trying (badly) to be/become functional, so maybe we’ll see how that goes. Any particular functional language(s) that you favor?

yeah functional oxygene. I wish you had done that.

How far did you get with f(Oxy) ?

Not beyond initial brainstorming, i’m afraid.

For my understanding, what would make Oxy a functional language?

It would be great if Oxygene supports

  • pattern matching
  • discriminated union (like F#) or Enum (like Rust)

I personally hate curly braces (like those of C++ or C#), and love F#’s using indent for code blocks, which makes code neat. Oxygene’s begin/end is quite verbose - let me dare to ask a crazy question - would it be possible for Oxygene to support indent-based code blocks?

1 Like

I don’t think thats a good idea to impose on an existing and mature language such as Oxygene.

I’m not a fan even in general, for languages that were designed with it (Python does that, right?) but I think it would be a terrible idea to add it to an existing language. Also how would we distinguish between the two modes? eg is

if foo then

a block with two statements, or just badly indented code (off which there is a lot :wink:


I have to agree.

It is not a pure functional language (like Haskell), though, Oxy is indeed a modern language that supports functional programming (like LINQ, anonymous function, lambda expression) like C#.

To be honest, i don’t even remember the ideas we had back then, it was so long ago ;). I’ll need to see if i can dig out the old spec somewhere, but this was like five different infrastructures ago…

Since we’re discussing languages and syntax. I think it’s interesting how many of the newer languages, in say the last ten years, all seemed to have adopted a Pascal-like syntax especially concerning placing the datatype identifier after the variable with an interceding colon such as num1: Int — compared with the C-syntax based languages int num1. Some of these languages will not mention a Pascal influence, but rather a Modula-2 or Oberon influence maybe because it sounds cooler :slight_smile:


fun sumTwoNums( num1: Int, num2: Int ): Int {
    return num1 + num2


func sumTwoNums( num1: Int, num2: Int )-> Int {
    return num1 + num2


   static function sumTwoNums( num1: Int, num2: Int ): Int 
       return num1 + num2;


sumTwoNums :: proc( x: int, y: int ) -> int {
	return x + y


fn sumTwoNums( a: i8, b: i8 ) i8 {    
    return a + b;


fn sumTwoNums( num1: i32, num2: i32 ) -> i32 {
    num1 + num2


function sumTwoNums( num1: number, num2: number): number {
  return num1 + num2;

One of the few languages that maintained a C/C++ - like syntax is Dart

int sumTwoNums(int num1, int num2) {
  return num1 + num2;
1 Like

Ocaml (it even has a syntax of using “begin” “end”)

1 Like

Sooo … any hints on language numbers 7 and 8? :nerd_face: I’m guessing WebAssembly doesn’t count :upside_down_face:

That’s a platform, not a language, and already supported :wink:

1 Like

TypeScript may be…

1 Like

Hi mh,

I really wants the 7 or 8 language to be kotlin. There are many benifits:

  1. Kotlin can use the .Net framwork, and be able to write .net, Uno, GTK# application, etc. Kotlin lacks good UI framework before, now it has Jetpack compose, which is really cool, but it does not support iOS at the moment.

For hobbist and non-professonal developer like me, I simply do not have so much time to study KMM and troubleshooting. I really like things such as Uno, it saves me a lot of time.

  1. Kotlin will be able to write native iOS application.

  2. The Go library will be availabe to Kotlin on .net like Oxygene and siliver.

  3. Looks like Kotlin now is the only language that can support compose (java does not support it, not sure other Remobject language), for language on JVM, I think Kotlin should have priority for Remobject to support it, although I unstand that all language are equal in the Remobject family.

  4. Many people will knows Remobjects:)


You’re not wrong.

The core compiler team is currently busy on two different big projects (non-language, but new (sub)-platforms), but i’ll throw this idea back in as a contender for the next big thing to look at afterward and/or for when @ck next time tells me he’s bored and wants an exciting new big task ;).