Vert.x 1.0.final is released

It’s been a long road but Vert.x 1.0.final has now been released :)

What is Vert.x ?

Vert.x is the framework for the next generation of asynchronous, effortlessly scalable, concurrent applications.

Vert.x is an event driven application framework that runs on the JVM – a run-time with real concurrency and unrivalled performance. Vert.x then exposes the API in Ruby, Java, Groovy and JavaScript. So you choose what language you want to use. (Scala, Clojure and Python support is on the roadmap too).

We also bundle a host of goodies out-of-the-box including a distributed event bus, Web Sockets, SockJS, a MongoDB persistor and many other features so you can write real applications from the set-off.

Some of the key highlights include:

  • Polyglot. Write your application components in JavaScript, Ruby, Groovy or Java. It’s up to you. Or mix and match several programming languages in a single application.
  • Super simple concurrency model. Vert.x allows you to write all your code as single threaded, freeing you from the hassle of multi-threaded programming. (No more `synchronized`, `volatile` or other explicit concurrency control required).
  • Unlike other popular event driven frameworks, Vert.x takes advantage of the JVM and scales seamlessly over available cores without having to manually fork multiple servers and handle your own inter process communication between them.
  • Vert.x has a super simple, asynchronous programming model for writing truly scalable non-blocking applications.
  • Vert.x includes a distributed event bus that spans the client and server side so your applications components can communicate incredibly easily. The event bus even penetrates into in-browser JavaScript allowing you to create effortless so-called real-time web applications.
  • Vert.x provides real power and simplicity, without being simplistic. No more sprawling xml configuration files.

Vert.x is a community project sponsored by VMware.

Future applications will largely be running on mobile and embedded devices. These demand a platform that can scale with 10s, 100s or even millions of concurrent connections, and allow developers to write scalable, performant applications incredibly easily, in whatever language they prefer.

We believe Vert.x is that platform.

If you don’t want the whole platform, Vert.x can also be used as a library in your Java or Groovy applications to enable them with all the async goodies.

For more information, please visit the website or visit the project on github

There are plenty of code examples, and a tutorial which shows you how to create a real-time web application without any server side code!

We are actively looking to grow the Vert.x community. Please join us on github, or the Google Group and get involved.

There is plenty to do, and we would love to have you on-board.

About these ads
This entry was posted in Uncategorized. Bookmark the permalink.

14 Responses to Vert.x 1.0.final is released

  1. fat bold cyclop says:

    Ok, ok. But…. Is it web scale? ;-)
    (http://www.mongodb-is-web-scale.com/)

    • Tim Fox says:

      The question is facetious, but this is actually a good point.

      One of the goals (but not the only goal) of Vert.x has been to be a “better Node.js”. Node.js has some great ideas but also does some things poorly.

      E.g. making everything run on event loop led to the farce around the “Fibonacci number generator” thread (if you remember that). These kinds of things combined with the naivety of some in the Node.js and other communities, led to the whole “is it webscale?” meme.

      Vert.x from day one, has avoided the crappy parts of a node-like approach and embraced the good bits. E.g. vert.x is not single threaded – we scale seamlessly over available cores without forcing you to manually glue single threaded servers together. Also we don’t make you run your Fibonacci generator on an event loop! ;) (We support worker threads for this kind of thing)

      To answer the question literally, “Is Vert.x webscale?”. If anything is, it’s Vert.x, or at least you can build “web-scale” systems using it.

      Vert.x is broader in remit than node and is designed to scale seamless over available cores, and comes with a distributed event bus built in so you can scale out to many servers. The event bus even reaches into client side JavaScript which increases the scale further.

      Vert.x is also designed to cope with thousands if not millions of concurrent connections – this is something that is going to be increasingly important as more apps go to the client side with long lived persistent connections.

      So, is Vert.x webscale? I’d say so ;)

  2. Rei-chan says:

    Will give it a try this weekend, sounds promising.
    Do want a cleaner Jython and/or Clojure interface, too.

  3. Hander says:

    And Lua scripting (LuaJ)? That could be awesome!

  4. uadetector says:

    Thank you for releasing vert.x. Many developers using The Central Repository to resolve dependencies. When will be the first release available there?

  5. capecoder says:

    When is Scala support coming?

  6. Pingback: Revue de Presse Xebia | Blog Xebia France

  7. Hello, i think it’s interesting to repeat the experiment with node.js 0.8.1 , or to release the code of the two dummy servers made on vert.x and node.js to allow readers to repeat the experiment.

    In any case, impressive results!

  8. Pingback: VMware beansprucht Copyright an Vert.x-Projekt | virtualfiles.net

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s