Quorum Studio 2.3 October 16th, 2020

Quorum Studio 2.3 is a significant bug fix release and we highly recommend upgrading. Many systems have been worked on. Specifically, this release includes improvements to Android support, code completion, the text editor, and the data science libraries.

  1. Fixed a bug in code completion where lines with use statements or package files, but no class yet defined, would incorrectly fail early.
  2. Fixed a bug in code completion where certain classes would not show up in detecting what actions can be called (e.g., Drawable).
  3. Fixed a bug in code completion where if you had an action with a particular name, plus a left paren, it would double up and embed the name a second time when you pressed enter.
  4. Fixed a crash bug in code completion when you have certain characters in the character stream.
  5. Fixed a bug in filtering where the compiler could get in an intermediate state, due to threading, and the user interface would incorrectly ignore the request.
  6. Fixed a bug in code completion where the standard library was being incorrectly ignored in certain parse configurations.
  7. Changed the default functionality in code completion when creating a use statement. It now adds a dot and re-pops the window back up.
  8. Added context awareness to popup completion in package and use statements. If a completion is at the end, code completion will not add the dot, both for class values and 'all' statements.
  9. Fixed a bug in code completion where certain classes were not showing up in use and package statements
  10. Fixed a bug where the root package, Libraries, in Quorum would not show up in code completion.
  11. Changed the graphics for packages in the code completion interface. They are now orange squares.
  12. Changed the color of private actions to be magenta and reversed the direction of the arrow.
  13. Changed the color of actions to be blue in code completion.
  14. Changed the sorting behavior of code completion for classes and packages. By default, packages now show up before classes and are sorted separately.
  15. Changed the sorting order in code completion for primitive values, which have been pushed below actions.
  16. Fixed a bug in code completion where private actions and variables would show up even in situations where they were not supposed to.
  17. Fixed a bug in code completion where filtering as you type would, all of a sudden, stop providing correct values.
  18. Fixed a bug in the code completion menu where the system would incorrectly close the window as you are typing and reset the focus.
  19. Added a feature internally to code completion making it easier to detect the parse configuration currently in the compiler. This makes it easier to detect when the system is managing information in another thread.
  20. Fixed a bug in code completion where the system would sometimes default to a previously known parse configuration too aggressively.
  21. Fixed a bug in code completion where parent variables would show more information than they are supposed to. Now, when you type parent: it will show you each parent and any field that is available.
  22. Fixed a bug in code completion where parents would not filter properly.
  23. Fixed a bug in code completion where sometimes parents would override standard filters, causing the user to see only parent variables
  24. Pressing the help keys for items in code completion now reads out any description from the Quorum documentation about the action or field. If that action or field has no description, nothing is read. For many actions, this gives a screen reader user more information on what an action or field can be used for.
  25. Fixed a bug in the text box where you could not navigate to the defining class for fields
  26. Fixed a bug in the text box where use locations for variables would not allow you to jump to the definition location
  27. Fixed a bug in the text box where constructors were being ignored in regard to their jumping behavior
  28. Added a way to create a folder from the project tree in Quorum Studio.
  29. Changed the basic ideas behind DataFrameColumn objects. Previously, we were trying to avoid directly iterating over these items, thinking we could avoid it in other ways. In practice, however, it was impractical, and as such these structures have been provided a series of new actions for manipulating them. All previous actions are still supported and we imagine more changes are coming as the broader data science libraries are fleshed out.
  30. Fixed a bug causing Quorum Studio to fail to send an APK file to android devices on Mac.
  31. Fixed a bug causing Quorum Studio to issue the wrong Android translation command on Windows.
  32. Significantly improved the error reporting and console output for Android translation. It now gives you much more information as to what you are doing and tells you whether it succeeded or failed.
  33. Added a log file for any build from Android. The location is placed in the console after a build.
  34. Fixed a bug causing applications built in Quorum 8 latest to crash on Android.
  35. Changed the default Font system to use FreeType on Android. This allows a much wider variety of Quorum's standard library to be used on the platform.
  36. Fixed a bug causing File IO to sometimes report incorrect information if the files were placed in Android's asset manager folders.
  37. Added a series of new plugins related to File IO on Android
  38. Cleaned up the default Android Gradle materials.
  39. Fixed several bugs in the properties dialog related to asset files on android.
  40. Fixed a bug causing font colors in buttons to not show up correctly.
  41. Labels now set their description field for accessibility by default. This way, if a label is told to accept focus events, screen readers have more information.
  42. Added missing functions to the button class to set the label directly without using the name field.
  43. Added an action to buttons that allows you to load an image more easily. The action is named LoadImage.
  44. Fixed several bugs in textbox selection, which were causing a crash under weird conditions related to the home and end keys.
  45. Fixed an issue where physics objects didn't update the position of children items
  46. Added a calculation for Skew
  47. Added a calculation for Kurtosis
  48. Added a way to gather z-scores for an entire column.
  49. Added a test for the Pearson Correlation.
  50. Added a test for the Spearman correlation.
  51. Added a transform to convert to ranks.
  52. Added a calculation for Inter-quartile ranges.
  53. Began changing naming conventions across test classes so that all of them have a consistent format. In this version, this changes the regression class and will impact others over time. These changes do break backward compatibility with the library. Given this library is experimental and documentation will not be written for it until it has gone through more rounds of review, we are pushing up these changes now.
  54. Changed the variance calculation to automatically calculate a mean if the mean was not set. It is slightly less efficient if calculated this way, but is optional and feels more intuitive. This was requested by a user.
  55. Added a class for calculating the standard deviation. Technically, you can calculate this from the variance, but having a class by this explicit name was a user request.
  56. Added custom input classes, ColumnInput and FactorInput, which standardize the way you send information to the various transforms, calculations, and other operations. Not all classes have been converted, but as we continue refining these classes, we suspect they will be.

Quorum Studio 2.2 September 8th, 2020

This release adds in some new features related to data science. Notably, we have added some charting procedures and made some quality of life improvements to the data science libraries as they are developed internally.

  1. Added Bar charts, Histograms, and Scatter Plots. Each of these plots generates graphs that are both accessible and visual. This is an initial release for feedback as our data science libraries are created.
  2. Added several helper classes for creating plots from a data frame, with names like BarChartCreator, HistogramCreator, and ScatterPlotCreator.
  3. Added an InterquartileRange class in the statistics packages
  4. Added a Summarize class in the statistics packages
  5. Added the ability to save into the DataFrame using a saving architecture.
  6. Added a ToText action to the DataFrame, which by default outputs any dataframe as CSV format
  7. Added a way to convert and adjust columns in data frames more easily. The purpose of this was to make it easier to create better transforms
  8. Fixed a bug in Git support not allowing cloning on Windows
  9. Fixed a bug in Git support that could cause a crash on certain kinds of diffs.

Quorum Studio 2.1 August 4th, 2020

This is a sum up release for a wide variety of changes to Quorum Studio. Note that we did not produce release notes for Quorum Studio 2.0.1 and 2.0.2 and these notes only reflect a summary of changes between that version and 2.1. All of these changes were made during the Microsoft Hack for Good Hackathon in 2020. We focused exclusively on accessibility and based decisions on what to work on on interviews with users at EPIQ 2020 and broad community feedback since the release of Quorum Studio 1.0. There is still more to do, but we feel as if these changes were a huge success. Notably, we were able to conquer most of the major remaining stability issues in the accessibility system. On our end at least, the major components are working much more smoothly, and consistently, with screen readers. Here is the list of changes:

  1. Rewrote the textbox accessibility components. It should now be much faster across the board, in addition to being far easier to maintain.
  2. Fixed a bug causing textboxes to sometimes get out of sync between the accessibility and graphics system
  3. Consolidated the native components for text fields and textboxes
  4. Fixed several bugs in keyboard affordances with the textbox
  5. Fixed a bug causing several keystrokes to not work properly in text fields
  6. Made adjustments to the way text fields work in the accessibility system
  7. Fixed a bug causing Narrator to not work with textboxes
  8. Fixed bugs related to braille displays and textboxes
  9. Fixed a bug that could potentially cause screen readers to not recognize Quorum interfaces as a UIA component, forcing you to ALT tab or restart a screen reader
  10. Fixed a bug in the bootup sequence of Quorum, which was causing a black screen to appear for a short moment
  11. Fixed a bug in the startup sequence of Quorum causing accessibility to trigger at just slightly the wrong time
  12. Fixed a bug causing events to fire through the accessibility system before it is ready to process events
  13. Fixed several bugs in the shutdown of the accessibility system. These could sometimes cause Quorum Studio to hang when it was closed
  14. Fixed a bug in the scene editor causing items to read inconsistently in screen readers.
  15. Fixed a bug causing the scene editor to not work correctly in Narrator
  16. Changed the read properties in the scene editor to try and make it easier to use in a screen reader
  17. Fixed a bug in the splash screen causing the super adorable phrases to come out at the wrong time or inconsistently
  18. Changed the loading screen messages to follow semantic prioritization. They are now shorter and easier to understand
  19. Fixed a bug in the splash screen system that was causing it to send update requests on the wrong thread
  20. Fixed a bug in the splash screen screen causing the progress bar to read in an irregular fashion. Note that while the properties of the progress bar are correct, screen readers individually choose the exact phrases they read
  21. Fixed a bug causing cells to state the wrong phrase in tables
  22. Improved semantic prioritization of cells by changing the read order
  23. Fixed table keys in tables. Note that each screen reader implements these differently and not all may equally respond to UIA tables or even support table keys
  24. Fixed a bug causing tree tables to just say "Cell"
  25. Fixed a bug causing the compiler error table to sometimes crash or send you to the wrong spot
  26. Removed several providers from tables, which were causing them to read slightly strangely
  27. Changed the default providers for tree table.
  28. Rewrote from scratch the dialog properties in UIA
  29. Change the providers and properties dialog boxes sent. Note that these properties are now correct and while all screen readers should properly read them, not all do. We are confident this is a bug in some screen readers, not others. For example, while Narrator does correctly read the box and is compliant with the properties, NVDA 2020.2 appears to connect to the top-most HWND window pointer, thereby incorrectly reading the entire window
  30. Fixed a bug causing Accessibility notify events to not properly be read. Note that now, for important reasons, any accessibility Notify calls will be ignored in the CreateGame action in a Quorum Game. All calls to this action need to be done after CreateGame has completed.
  31. Fixed a bug causing NVDA to throw exceptions sometimes in the bootup sequence

All of us on the Quorum team want to give our extra special thanks to Microsoft for hosting us in their Hack For Good Hackathon this year. We would especially like to thank Matt Campbell, who besides being a wonderful person to hack on accessibility with, really helped this patch knock it out of the park. All of us hope you all enjoy the changes as much as we enjoyed hacking on them!

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: