Quorum Studio 2.0 July 10th, 2020

Quorum Studio 2.0 is the first major upgrade to our new development environment for Quorum. It includes major changes and upgrades across the board, which we outline below.

Scene Editor

Quorum Studio 2.0 includes a way to create accessible 2D games. How to make 2D games accessible is a major challenge and we suspect we could iterate on this design for decades. In the first version, we have focused on a scene and Palette tabs, which live in the project tree, and that allow you to either drag and drop or, with the keyboard, create maps, place characters, and set properties in a scene. Physics and many other things are controllable from a game and Quorum 8 natively understands these scenes in the game engine. These scenes can then be loaded in a native Quorum game. We find it to be much easier to create games in this new version.

Besides the features, we have included some default art in the Palette for creating games and have created a series of tutorials on how to use the system. More information about how to use it is located on the scene editing tutorial page. Finally, while 2.0 is adding only 2D support into the grid, 3D support is almost finished and already accessible. We have a few more features to finish there before release and users can expect that 3D support will be added in a few months.

Git support

We have added basic support for the Git version control system. This includes being able to push and pull repositories from Github or Bitbucket, annotations in the file editor showing file differences, and other operations. We have updated the documentation for Git support on the tutorial page.

Editor Upgrades

We have significantly improved the editor experience for Quorum Studio 2.0. There are now keyboard navigable annotations that show up in the editor, which indicate information like hints or Git file differences. In addition, we've improved performance and squashed a bunch of bugs in the editor. We have also included some accessibility hotkeys to give screen reader users more information about where they are in the editor. These keys are hooked up to a few other components as well and provide summaries or location info. This is especially useful, we think, in the accessible scene editor.


By popular request, we have created an auto-update system for Quorum Studio. In 2.0, you'll need to uninstall/reinstall 1.1 because of changes behind the scenes, but after that, Quorum Studio can update itself from the Quorum Servers. This also includes a 'live on the edge' track. If you are in the beta program, you can always grab the latest build from the Quorum team. This lets you grab exactly the same version our dev team uses when building Quorum Studio and Quorum. To get it, you can set the beta flag in your quorum studio preferences file. So far, this is intentionally not exposed in the user interface so users don't do it accidentally.


We have made considerable progress on optimization of Quorum Studio. On our end, small projects end up with a memory footprint in the range of 1 gigabyte for the system. For instances of Quorum Studio with multiple large projects open, like reading multiple versions of Quorum's entire standard library, we are getting in the range of 4.5 gigabytes after a day of continual use. CPU usage at idle is now down on our end to values we see that are comparable to Firefox, Slack, or other utilities. Compared to our older Sodbeans, we have calculated that for small projects we have ballpark a 50% reduction in memory usage overall. These numbers vary by operating system and usage, but the point is that we have made big strides this year and this should help the user experience, especially for those of us without access to high-powered machines.

Quorum 8.0

While we will not put out separate notes for Quorum this year, Quorum Studio 2.0 includes Quorum 8. Quorum 8 is largely a bug fix and optimization release. We have continued making the standard library faster, more robust, and more flexible. In addition, we have included integration with scenes right in. Besides this, we have made a considerable number of small changes to the libraries, adding extra actions here and there where we think it makes coding in Quorum just a little bit easier. For optimization, we have integrated a great deal of the improvements on memory and processor consumption into the standard library itself so that all users in the open source community can benefit.

Bug fixes

At a high level, we have made significant improvements across a number of systems. This includes, since our beta in the summer of 2019, more than 300 bug fixes either that we found or that were sent to us by members of the community.

Sodbeans End of Life

The team has made the executive decision to call 2020 the end of life for Sodbeans. We all enjoyed working on Sodbeans and, while it certainly had plenty of flaws and these are why we built Quorum Studio in the first place, it helped us build a community and changed the way we program in many ways. Notably, we could not realistically have built Quorum without it. We also want to thank the members of the NetBeans community, especially colleagues at Sun/Oracle, the old NetBeans Dream Team, or others like Geertjan Wielenga or Tim Boudreau that helped support us so much over the years. While we are super excited about our new direction and having our own toolchain to directly control accessibility has been a dream for years, we would not be here without that community's help and support and so we wanted to say thank you one last time!

Quorum Studio 1.0 December 13th, 2019

The Quorum team has been hard at work on a new development environment for the programming language, which we have code named Quorum Studio. In these notes, we have outlined some of the initial features. Quorum Studio is large and we do not pretend to document all of the features here, but we hope this will give readers the big picture of the first version. As this project has been in development for several years now, we are incredibly excited to get this to the community.

Quorum Studio Projects

Quorum Studio has its own project system. Like its predecessor, Sodbeans, we can create, load, close, build, debug, and take other actions on projects. Projects contain properties and preferences, which can be adjusted and customized. This includes simple things, like a project automatically loading into a Mindstorms LEGO robot, to complex things like loading custom plugins. All major actions that can be done in Sodbeans have been ported over to Quorum Studio.

Quorum Studio Preferences

Like many development environments, Quorum Studio remembers the way you setup the environment and automatically stores, loads, and adjusts these preferences as you use it. Generally, most major systems in Quorum Studio are automatically plugged into this preferences system and users do not need to do anything to use it.

Quorum Studio Installer

In NetBeans, we had to require behind the scenes and somewhat custom installation of Java and other dependencies, which became complicated as Oracle tightened their license agreements. Eventually, this forced us to recommend users switch to OpenJDK, which made installation even more complicated. Over time, this felt to the development team like this process was getting harder and harder for teachers and students. In Quorum Studio, we bundle the minimal subset of additional dependencies in with the installer on Mac and Windows automatically. Generally, if the installer is used, everything required by Quorum Studio should be included without altering system settings and without any complex additional steps.


Quorum Studio offers many industry standard features for software development. This includes user interface elements like tabbed panes, syntax and semantics highlighting editors, console output windows, breakpoints, compiling, and debugging. We have remapped many of the default hotkeys away from the defaults in NetBeans to make them more intuitive. Normally, we are now using the first letter of an operation as a mnemonic. For example, running a program would be COMMAND + R on Mac or CTRL + R on Windows. Many other hotkeys have been default remapped similarly.


Editing source code in Quorum Studio has many common features, like syntax highlighting, semantics highlighting, editor hints, code completion, and other features. There are new editor hints compared to Sodbeans, like automatically generating getters and setters, and old ones are retained, like automatically generating use statements. Some of the color choices are now slightly different, like the use of purple to imply constructs that have a matching component (e.g., if and end).


As always, the Quorum team cares deeply about accessibility. Quorum Studio is built on the hardware accelerated graphics platform in Quorum itself, which automatically connects down for accessibility (e.g., to screen readers). Besides screen reader connections, we have smart zooming features, keyboard shortcuts for a great deal of operations, and have worked hard to make navigating around the environment accessible and intuitive. In our first release, we only support screen readers on the Windows 10 platform. If we are lucky, we'll be able to raise enough capital to add other platforms over time.

Quorum 7.5

While we normally put out new versions of Quorum once per year, this year we are making an exception and putting out Quorum 7.5. By far, the biggest changes are significant additions to the user interface libraries, which form the foundation of Quorum Studio. This includes, especially, a near complete rewrite of the accessibility backend. Some of the major changes include altering how the graphics system connects to the accessibility systems and adding a variety of helper actions for providing context to the accessibility system. For example, it is possible to now directly ask a user interface component to send an accessibility event, even if the on-screen graphics is doing something different. This, and many other features, is incredibly useful for a wide variety of potential applications.

A Quorum environment written in Quorum

Quorum Studio is written in Quorum 7.5 from the ground up. The development environment we are using to build Quorum studio is also, you guessed it, Quorum Studio. This means that at this point we are eating our own dog food for the full pipeline, including for evolving the pipeline. To put this in perspective, Quorum's compiler is written in Quorum, our standard library is in Quorum, and now our development environment is too. As we have slowly built up and built out our environments, this has made it easier for us long-term to make progress on the project as a whole and to cut our reliance on third party tools, which cannot always be relied on for accessibility.

Sodbeans deprecation

While we are excited about the release of Quorum Studio, with it comes just a tiny bit of sadness with the official deprecation of Sodbeans. While Sodbeans was always just a NetBeans derivative, with some accessibility enhancements and Quorum support, it was never as accessible as we wanted. It helped us start a community, but over time NetBeans was showing its age and was actively standing in the way of the innovations we wanted to make. As such, with the release of Quorum Studio, our development team has made the switch internally and we now use it exclusively for Quorum development. Further, NetBeans is no longer supported for the Quorum programming language and we do not plan to maintain it further. Schools and community partners can continue using it as they see fit, of course, but we suspect many partners will also make the change as Quorum Studio gets off the ground and matures over time.

Thank you

As a final note, we want to provide a thank you to the community. Building this technology was a long, multi-year process. It took way longer to invent than we imagined and there were considerable technical and human challenges along the way. A ton of community members participated in our beta programs, many of you before Quorum Studio was really ready for prime time. Especially, we would like to thank Sina Bahram (Prime Access Consulting), Matt Campbell (Microsoft), Ameer Armaly (Google), and all of the amazing teachers at the 2019 Experience Programming in Quorum workshop. Crucially, we also want to thank the National Science Foundation, which made it possible to fund this crazy adventure in the first place. Your feedback and support, whether through financing or feedback, was essential and we truly cannot thank you all enough.

Quorum 7.0 July 12th, 2019

Quorum 7.0, and its corresponding sister release, Quorum Studio 1.0 Beta, is a far-reaching and massive update to the programming language. Many systems have been adjusted and changed with many new libraries being added as well. At a high level, this includes: 1) significant changes to how accessibility is handled internally, 2) finishing off and in some cases rewriting many aspects of the user interface libraries, and 3) significant optimization efforts across the board. Many of these changes were created in order to make Quorum Studio work effectively and be accessible. We will not outline all of the changes, as there are too many, but these notes will provide a high level overview.

Quorum 6.0.5 - 6.0.7 July 21st, 2018

Quorum 6.0.1 - 6.0.4 July 14th, 2018

Quorum 6.0 July 2nd, 2018

Quorum 6 is part of a two-year release cycle for the language, adding a great deal of new backend materials, a new user interface library, significantly improved accessibility support, android support, basic network services support, and other features. Because many of the feature requests for our usual yearly cycle were so large, some we implemented about half in the first year. This is especially true for user interface support, with a good chunk of important interface elements included now, including the backend, with the rest planned for Quorum 7.

Further, as part of Quorum 6, we are hard at work on a new Integrated Development Environment (IDE) for the language, which we have code named Quorum Studio. The reason we did this is several-fold. First, by building our own interface libraries, we can directly control the accessibility pipeline, providing us far more freedom in research than was ever possible using NetBeans and Swing. Second, we also want to provide a way for the 'output' of the code people write to be natively accessible, even for highly graphical 2D or 3D content. Finally, NetBeans itself was moved to the Apache Foundation from Oracle. From a licensing and governance perspective, that's reasonable, but whether the environment will be financially supported, and for how long, is uncertain. As such, while NetBeans will not be supported in Quorum 7 and beyond, we expect all future releases of Quorum to be available in the console, on the web, and on the desktop in Quorum Studio.

Below is a list of all major features in Quorum 6. As usual, the list abridged to provide the highlights:

Finally, because our release cycle this year is unusual and we are at the halfway point for parts of the project, there are several known issues. This list this thus includes a few known bugs that will be fixed in a patch as well as some features that are being worked on currently.

Quorum Patches

This is a list of patches pushed to live. For small patches pushed by the team, we sometimes write notes for the last several. This should be considered an abridged list of changes.

Quorum 5.0.13 September 15th, 2017

We made a small patch to Quorum this week and additionally upgraded the website. These changes included:

We would like especially thank Sarah Judd at Girls Who Code for helping us in the design of the new project system.

Quorum 5.0.11 June 2nd, 2017

We fixed a bug on Desktop that caused the IsPlaying action in Audio to crash if used while streaming AudioSamples.

Quorum 5.0 June 1st, 2017

Quorum 5 is the next significant update to the programming language. Notable enhancements include a new physics system for 2D and 3D games and a new digital signal processing engine. Finally, we have significantly improved web support and now much of the language can be run in a browser, on iPhone, or on Desktop.

Quorum 4.0.6 January 21st, 2017

This patch includes a variety of small changes as we continue with Quorum 4. Besides the fixes below, this version includes a new version of the website, which should bring us one step closer to web support for many of Quorum's features.

Quorum 4.0.5 September 9th, 2016

This patch includes a variety of small changes as we continue with Quorum 4:

Quorum 4.0.4 August 6th, 2016

This patch fixes a variety of issues found at EPIQ 2016 and after by users. This patch includes:

We would like to thank Sina Bahram, Pranav Lal, and DJ Prater for their help in identifying some of the problems in the above list.

Quorum 4.0 July 5th, 2016

Quorum 4.0 is the next major update to the programming language. In it, we have provided a variety of new features and improvements for many systems. The highlights of this release include support for 3D gaming (audio + visual), mobile support (iOS only), and significant improvements across the board to the development environment (e.g., navigation, folding). Besides these larger changes, we have spent considerable time making improvements to a large number of systems in Quorum and have expanded on many. This includes the addition of linear algebra libraries, improvements to the existing LEGO libraries, and significant improvements to the design of the game engine. Finally, we have added many new tutorials on a variety of systems.

3D Gaming

One of the major features in Quorum 4.0 is a new 3D gaming system. On the backend, Quorum uses OpenGL, one of several standard gaming engines for commercial games. On the user level, however, we have spent significant effort working with people writing games in Quorum to try and iterate on our design. Overall, the 2D system has been improved and simplified in a variety of ways, the overall libraries have been unified, and accessibility support is now baked in in ways we think are easier to understand.

Besides this, 3D support itself has been modeled similarly to 2D. In other words, with 2D, you could load an image or sound and move it around. With 3D, while traditional modeling applications in OpenGL or Direct3D require quite a bit of knowledge about computer graphics, our libraries try to simplify those aspects of the system that we can. The idea is, besides the added dimension, to make the 2D and 3D systems feel as similar as possible to the programmer to aid in learning. Here are some additional highlights for the new engine:

Visual Games

The visual aspect of Quorum has now been significantly improved. We now support 3D games, built on our linear algebra library. We have also conducted significant user testing on creating games with our libraries and have spent considerable time re-tooling them in order to make them easier to use. This was conducted for both the 2D game system and the newer 3D one. To make things easier, we have also unified the libraries for 2D and 3D games, so that the way you interact with them is as similar as possible. Below are some highlights from the visual part of the system.

Auditory Games

In addition to broad gaming features, we have expanded on the auditory system in Quorum. Here are the features we now support.

Development Environment Improvements

This update adds a variety of development environment features. This includes brace matchers, highlighters, a rewrite of the navigator, efficiency improvements, and a variety of other features.

General Improvements and Bug Fixes

This section includes a variety of improvements or bug fixes the team worked on for this release.

Documentation Improvements

We have made a number of changes to the online documentation in Quorum, including adding a variety of lessons and tutorials. These include:

Quorum 3.0 Update 48 July 22nd, 2015

This update is deployed to the update centers.

Quorum 3.0 Update 44 July 21st, 2015

This update is deployed to the update centers.

Quorum 3.0 Update 43 July 16th, 2015

This update is deployed to the update centers only.

Quorum 3.0 Update 42 July 9th, 2015

This update is deployed to NetBeans only, but not as a separate zip file on the release servers.

Quorum 3.0 Update 41 July 8th, 2015

This update is deployed to NetBeans only, but not as a separate zip file on the release servers.

Quorum 3.0 June 30th, 2015

Quorum 3.0 represents the most significant change to the Quorum programming language since its inception and is a near-complete rewrite. When the Quorum project first began, it was written in Java, was interpreted, and we were really just trying to make programming a little easier. As of 3.0, the project has gone further than we ever imagined: Quorum is now faster, robust, and written in itself. As is a long tradition in programming language design, once a language is sufficiently powerful to write the next version in itself, so-called self-hosting, it is a sign that the language is becoming increasingly mature. On Quorum, we have finally reached this milestone and will now be shifting our attention to improved library and development environment support. Library requests to the team, or contributions, are welcome.

We had a number of technical goals in mind for the Quorum 3.0 release. We highlight some of the most significant alterations below:

Standard library changes

Integrated Development Support changes

Major language changes

Type system/variable changes

Exceptions (Error) system changes

Control Structure changes

Compiler Support

Other changes

Quorum 2.1 December 16th, 2013

Standard Library and compiler Fixes/Changes

Quorum 2.0.1 August 13th, 2013

This is a bug fix release for the Quorum 2.0 branch.

Quorum 2.0 June 6th, 2013

Quorum 2.0 includes a host of improvements to the type system, adds the ability to call actions on primitives, includes minor syntactic improvements, and enhances the code completion helper libraries.

Quorum 1.7 February 25th, 2013

Quorum 1.7 adds in a new type inference system, upgrades the internal architecture substantially, and fixes a number of known bugs.

Quorum 1.6 September 9th, 2012

Quorum 1.6 contains a number of important bug fixes.

Quorum 1.5 June 26th, 2012

We previously had the following:

if a = b then
end else if c = d then

end else then

The syntax is now the following:

if a = b
elseif c = d


We may change the design of this construct again in the future if we find more, or better, evidence for against any particular design. Users, or other researchers, that have conducted formal empirical studies, with corresponding evidence, that they think might illuminate more decisions here should let us know.

Quorum 1.0 January 30th, 2012

This is the initial release of the Quorum programming language. Currently, Quorum has the following features: