Languages Platforms IDEs | Download Pricing |
coming soon


Codename "Mercury" is a BASIC language implementation that is backwards code-compatible with Microsoft Visual Basic.NET™

Write VB-compatible Code, for Any Platform

With Mercury, you will be able to build your existing VB.NET projects, and leverage your Visual Basic™ language experience to write code for any modern target platform. That includes:

  • .NET, .NET Core, Mono and ASP.NET Core
  • The Java VM and any device that runs Java code.
  • Android, both the Java-based SDK and the CPU-native NDK
  • iOS, macOS, tvOS and watchOS
  • Windows (CPU-native)
  • Linux (CPU-native)
  • WebAssembly, for web browsers and Node.js

You can read more about the platforms supported by the Elements compiler, here, and the full Visual Basic™-compatible Mercury language syntax will be available on all of them. And of course you can mix Mercury code with any of the other five Elements languages in the same project, if you like!

Sophisticated IDEs for Windows and Mac

The Mercury language will be deeply integrated into our development environments. Develop you projects in our smart yet lightweight IDEs, Water on Windows or Fire on Mac – with project templates, code completion, integrated debugging for all platforms, and many other advanced development features. Of course Mercury will also integrate into Visual Studio™ 2017 or 2019.

Mix Mercury Code With Other Languages

With Elements, all languages are created equal. Even within the same project, you can mix Mercury, C#, Swift, Java, Oxygene and Go.


Mercury, like the other five Elements languages, comes with an extensive tool chain that takes care of all parts of your development process – from IDEs to work in, over the compiler and auxiliary build tasks, all the way to your final product.

It also integrates deeply with the existing ecosystem for whatever platform(s) you are targeting. For example:

  • On Mac or iOS, you have full access to the entire range of Cocoa APIs. You can use .xib files, storyboards, asset catalogs etc. just as you would in Xcode.

  • On Android and Java, Mercury seamlessly uses the platform tools for "dex'ing" your Java code or creating .apk files, and has support for pulling in external Gradle packages like you'd expect.

  • On .NET, you have full access to the framework library and third-party .dlls and libraries, and you can use NuGet packages to pull in code. You can target the full desktop .NET Framework, as well as .NET Core or Mono. And so on.

... and so on.

Language Extensions

As part of the Elements family, Mercury automatically inherits a lot of additional special features, including but not listed to:

  • Compiler based cross-project Obfuscation (no external obfuscation tool needed anymore)
  • Aspect Oriented Programming (generate code from aspects)
  • Duck Typing (convert types to other types that you normally could not)
  • Soft interfaces (lets you use a type that does not implement an interface, but has the correct functions for that interface use as that interface)

While building Mercury, we are also looking at VBLang for historical requests, and see what we can add to our implementation. At this stage we already implemented the following requests: (This list is expanded each time we implemented something):

  • 19 - optional parameter implicit type conversion
  • 20 - NameOf(obj) function that gives back a string with the full qualified variable name as it is in the source
  • 29 - Implicit Default Optional Parameter
  • 41 - Allow Single Line Comments in more places.
  • 43 - variable scoped late binding (solved with Dynamic type)
  • 46 - Add Support For Pointers
  • 65 - Allow comments after explicit line continuations
  • 73 - Extension Property
  • 135 - Late-binding without requiring Option Strict Off for entire file or project
  • 174 - Make the Optional keyword optional
  • 183 - Implicit Line-Continuation Comments
  • 211 - usage of any installed programming language
  • 271 - comments "inline"
  • 300 - unmanaged type parameter
  • 354 - Make Optional optional
  • 406 - WebAssembly Compiler for VisualBasic.NET™

Additional candidates are:

  • 24 - Case ... When ... Clauses
  • 63 - Allow overridable and overriding events
  • 87 - TryCast should support nullable value types as its target type
  • 92 - Implicit interface implementations
  • 96 - Generic Property
  • 152 - Out arguments
  • 164 - Can't call extension methods on Object
  • 169 - Using readonly property as target of ByRef
  • 186 - Exit For j Statement to Break Out of Nested For and For Each Loops
  • 204 - Add shadow classes as a way to extend sealed classes.
  • 210 - member functions in Enums
  • 355 - Nullable References

To stay in the loop, follow @VBMercury and @ElementsComp on Twitter.

And discuss Mercury in the Visual Basic community on

* Visual Basic™ and Visual Studio™ are trademarks of Microsoft Corperation.*

Love the idea of Mercury, but prefer a different language?
Check out RemObjects C#, Swift or Iodine (Java) or Oxygene!

What's new?   |   Forums   |   Twitter   |   Facebook

What's new?