Quorum Studio 4.6 and Quorum 10.6: January 9th, 2023

We have created a small maintenance release for Quorum Studio. This release was made because in Quorum 10.5, there was a change to the way shaders and batching worked in the graphics engine, which was causing several interface components to render a bit funny. We like funny as much as the next folk, but this was not intended. While working on those systems, we noticed a number of performance and memory issues that we have now fixed. In internal testing, the performance improvements compared to Quorum 4.0.3 are quite substantial. Notes follow:

  1. Fixed an issue with checkboxes and radio boxes in terms of rendering, which was causing them to look visually like they were not responding. Accessibility was not impacted and they still worked under the hood.
  2. Fixed several small graphical and unmemorable glitches in Quorum Studio. We say unmemorable because we cannot really remember what they were, but they annoyed us so we fixed them.
  3. Significantly reduced the memory footprint of the Matrix class. The difference is quite large. In internal testing, it is in the ballpark of a 90% reduction, although the actual number depends on the size of the matrix.
  4. Removed instantiating Object from the multiple inheritance architecture, rewriting the semantics of what it means in Quorum. Assuming we did not make a mistake, users will not observe any difference in how they use the language, however the memory footprint of Quorum has been significantly reduced because of this change. In Quorum Studio, for example, we are clocking a reduction of about 150 million unneeded objects no longer being created. The objects were small in size, but there were a lot of them, which means that in our internal tests, the memory footprint dropped by about 5%. Other tests, like charts, were more dramatic, with nearly a 35% reduction achievable only by recompiling the same program.
  5. Because of the change to the multiple inheritance system, Quorum throws away less useless objects and no longer has to create them, reducing garbage collection. In internal tests, we are noticing about a 25% reduction in the amount of memory reported by the operating system after bootup
  6. Completed the multiple inheritance change in JavaScript mode as well. This shrinks the overall rather large uncompressed standard library file by about 1.5%, due to cutting out a series of operations that were no longer needed in this version. The memory optimization impact was not carefully evaluated, but it should have theoretically similar impacts to bytecode modes.
  7. On ARM processors for Mac, after all of the optimizations and comparing the Intel version of 4.0.3 to ARM, we are noticing a 57% decrease in bootup time and a 9% drop in CPU usage.
  8. Significantly reduced memory consumption of scatter plots. While it depends on what you pass, in our test, which used an approximately 1200 x 15 sized data frame, this reduced memory consumption by 88.5% and dramatically sped up rendering and loading speeds. While this is nice in general, it also improves screen reader accessibility speed significantly.
  9. Because of the inheritance changes, Quorum Studio 4.6 is not binary compatible with previous versions. We have added a double bootstrapping function to Quorum to auto-build Quorum Studio using both an overridden standard library and a source compiler. We recognize this is barely English, but are really just saying that we added some code to make it easier to make breaking changes to the backend compiler in the future and to integrate those automatically in Quorum Studio for usage in our tests.
  10. Replaced the table implementation in matrix with the newer DataFrame class behind the scenes
  11. Added a VectorColumn for more optimized numerical operations in DataFrames. This removes auto-boxing inside of a frame, which means if this column is used, no undefined values can be allowed. It is a speed trade-off and optional
  12. Added an optimization to the Comparison class for default primitive sorting
  13. Added support for Comparisons inside of the Vector class
  14. Fixed a memory leak in ShaderProgram causing a considerable number of Text objects to be auto-boxed accidentally
  15. Changed the Item and Control classes to not instantiate all of its arrays by default, which saves memory
  16. By default, the Regression class no longer retains matrices related to the computations it made. This passes all of our internal unit tests and on code inspection, seems ok. The purpose is to reduce memory consumption after the regression is done calculating and this is significant for large files. That said, if for some reason we cannot think of, a user needs that object retained after computation, a flag may be needed to support it, even if the default is to destroy it.
  17. Fixed a bug with ChartComparison where it was creating and throwing away extra objects
  18. Lowered the default number of vertices used in the Polygon class, as it was not using the vertices for the common case.
  19. Fixed a bug in Polygon that was creating an extra vector that was being thrown away.
  20. Fixed a bug where HTML reserved characters were not properly handled when processing SVG images.
  21. Fixed an issue where if you were on an ARM chip on Mac, the updater would grab the Intel based version of Quorum Studio. Users need to re-download from the website to fix this, but it should be easier to update from here on
  22. Migrated file downloads to github releases. We will be using this system from here forward to reduce server load and just generally more conventional.
  23. Removed the final PHP file from the server backend. Quorum now uses only Quorum for hosting Quorum on the Quorum server.
  24. Fixed a bug in Quorum Studio where in the code completion, if you had an empty set returned, it would be too aggressive on showing you an empty window
  25. Changed the auto-update scripts to account for the change to github
  26. Fixed a bug in text fields where double click was not working
  27. Fixed a view in text fields where the view was not correctly updating visually with the cursor in some situations
  28. Fixed a bug in text fields where triple click was not working

Quorum Studio 4.5 and Quorum 10.5: December 7th, 2022

Quorum Studio 4.5 is the next major version of Quorum Studio and contains a series of enhancements and changes. As our current focus is on especially our move toward adding accessible blocks to the language, in addition to accessible data science, this is an intermediary release along that path. This is also the first release to officially support the M1 mac, as we slowly move toward improving our Mac support. For this first release supporting this chip, those on M1 chips need a separate download on the website and should not use the auto-updater.

Accessible Data Science

We have added support for a considerable number of statistical tests and procedures, along with many bug fixes. We did a considerable amount of refactoring along the way, which means we should be ready by next summer to have users try the statistical aspects of the system

  1. Fixed a host of issues related to charts across the board
  2. Added support for a variety of parametric tests, including repeated measures anova, sphericity tests, chi-squared, shapiro-wilk, and others
  3. Added support for a variety of non-parametric tests, including Mann-Whitney, Kruskal-Wallis, Friedman, and others
  4. Adjusted, improved, and implemented various corrections, like Bonferroni, Tukey, Huynh-Feldt, Games-Howell,and Greenhouse-Geisser
  5. Added a set of convenience actions related to obtaining the results of statistical tests
  6. Added convenience actions for various kinds of statistical actions, like obtaining correlation matrices
  7. Added a helper action for generating scree plots for factor analysis
  8. Added a set of tests for factor analysis, including Bartlett, Kaiser-Meyer-Olkin, and others
  9. Adjusted and improved Accessibility across many chart types
  10. Added a feature for live captioning of charts as you navigate them
  11. Fixed many bugs related to statistical actions, which now have much more rigorous testing related to what they output

Planning for Accessible Blocks

The Quorum team is targeting adding a block mode to Quorum online and Quorum Studio by approximately Quorum Studio 5 and Quorum 11. Along the way, we have been developing a custom accessible rendering pipeline related to such systems and this includes at least the following features:

  1. Expanded the shader system to account for the design of blocks. This way, you do not need images or SVGs for rendering and it can be done in hardware.
  2. Created a hardware batched rendering system generally, with especially an eye out for blocks. This significantly improves performance for graphics across many systems, but is especially useful for charts and blocks. User interfaces do not yet take advantage of this approach, but may also benefit in the future from it
  3. Migrated the code for the scene editing system from Quorum Studio to the Quorum Standard Library. The purpose in this was to have accessible scene editing offline and online, available both inside and outside of Quorum Studio. We hope this technology could make it possible for curriculum like Computer Science Discovery to be fully accessible
  4. Integrated a number of fixes to Quorum's shaders, including those impacting Pie Charts on Android

Database and Web Services

The Quorum Database library has been a work in progress since publishing our paper on polyglot programming. We are now feature complete with this work and are pushing the system live across our stack. Finishing this system has significantly improved the ability of Quorum to be used in a common docker container for backend web services. Now that it is finally going live, the most current features include:

  1. We implemented a series of minor bug fixes in the database system.
  2. Pushed the database stack live and replaced any database related code with Quorum
  3. Added a series of web service libraries necessary for server side scripting in Quorum
  4. Replaced the Quorum live server's PHP system with Quorum, with the exception of the download page, which we didn't bother with this release
  5. We have added a considerable amount of documentation for the database system onto the Quorum reference page
  6. Because PHP has been replaced with Quorum, Quorum's live server can now service compilation requests an order of magnitude faster than before
  7. Added a way to send raw network requests from TCP in the SocketConnection class in Quorum

General Features

We made a number of improvements to the system broadly. Big picture, these included:

  1. Added support on mac for the M1 processor to Quorum-language and integrated it additionally into Quorum Studio. This significantly improves speed on this platform. Machines on Intel based chips are still supported
  2. Rewrote the native libraries on Mac to considerably clean it up for future development
  3. Added preliminary support for the Talkback screen reader on Android. This is a preliminary proof of concept release targeting charts and is not yet feature complete. It is, however, a start and now that we have successfully tapped in, it can be adjusted over time if there is interest from the community
  4. Fixed a number of minor issues in the Quorum compiler

Quorum Studio 4.0 and Quorum 10.0: June 15th, 2022

Quorum 10.0 and Quorum Studio 4.0 is the 2022 release for the programming language and corresponding development environment. We focused considerably for 10.0 on improvements to the language in regard to making it better for data science. This includes significant improvements to charts, many data science actions, and the database system. Besides this, Quorum 10 includes a significant change to the look and feel of any user interfaces built into the system, including Quorum Studio. There are many new colors across everything and are swappable as light or dark modes. As always, we have continued to tweak and improve accessibility. With this release, we focused on getting the ground work in place for a future Quorum Blocks mode, which involved a great deal of refactoring behind the scenes.

Data Science Improvements

We made a number of improvements to how Data Science is done in Quorum for this release. This includes a myriad of changes to the DataFrame class, focusing on creating a set of helper actions and inspired by similar actions in the R programming language. We created these on recommendation from a statistical consultant (thanks, Amelia McNamara!) and plan to continue adding helper actions in the future. Big picture, the idea is, while we can always traverse and adjust a DataFrame manually, we are trying to make using DataFrames less of a hassle.

For this release, there are several big changes. First, we have continued on our limited polyglot integration by adding actions similar to R's mutate. This allows for the user to create new columns, calculated on the fly, using Quorum's normal syntax. Second, we added/refactored convenience actions for outputting to the screen limited versions of frames and additionally added actions to remove or replace undefined values, in addition to column and row splitting. This does not cover all the transformations we want to add, but it is a start and these are potentially useful.

Finally, we added a considerable amount of documentation for this release. This includes details on how you make DataFrames, control them, manage charts, and other factors. Detailed notes follow:

  1. Added a GetHeaders action to DataFrame to find all the headers of the columns without traversing them
  2. Added a new AddColumn action to DataFrame, which allows you to run a script to calculate the new column. For example, x1 + x2 * 3 would multiply all values in x2, add the values in the row for x1, then make a new column with this value
  3. Added a new action to DataFrame called CalculateColumn(text) that also uses a script, but instead of adding it, returns it
  4. Added a convenience action to DataFrame called CalculateMaximumRows. It, perhaps not surprisingly, calculates the maximum number of rows across the columns in the DataFrame
  5. Added a way for DataFrameColumn objects to understand the results from the runtime interpreter. This allows various kinds of mutation and filtering actions by letting sub-classes of the column interpret the results during execution
  6. Added two actions to DataFrame to allow for outputting only a portion of a DataFrame. They are ToText(integer) to get a number of rows and ToText(integer, boolean) to output a number of rows with or without a header
  7. Added two convenience actions for removing undefined values from a DataFrame. This includes RemoveUndefinedRows and RemoveUndefinedRowsFromSelectedColumns, which remove undefined values either from the entire frame or taking into account selected columns
  8. Added two convenience actions for replacing undefined values in DataFrame, similar to the removal actions
  9. Added the ability in each column type to replace all its undefined values with a separate value. If the value is not valid for a particular column type, it is ignored
  10. Added in the ability to split a column up with a delimiter from the DataFrame
  11. Added in the ability to split a data frame by rows, including random splits for selecting random sub-selections of the entire frame
  12. Added in a ColumnSplitter class that lets us override how column splitting is handled, while letting the base class handle all the traversals.
  13. Added in a way to select rows in a DataFrame. This currently does not impact chart creation or other operations
  14. Added in a way to select arbitrary cells in the DataFrame. This currently does not impact chart creation or other operations

Database Changes

Quorum 9.5 introduced a new Database system for Quorum and we have continued this work in Quorum 10. While we are using this new system internally for projects, we would argue it is still in beta. That said, we did make a number of improvements to it, including continued work to make that system feel seamless when used across Quorum. In terms of documentation, we have not yet written any, because again we still consider this version a public beta. Ultimately, we are planning on switching the Quorum live and beta servers to this system entirely and once we do, that is the flag for the team that it is ready for production. We will likely write documentation at that point. Notes for the changes and improvements follow:

  1. CreateTable can now add text columns with no size specified. These text columns can store a string with a max length of 65,535
  2. Added auto increment to integer columns in a CreateTable query
  3. Number, Boolean, DateTime, Date, and Timestamp columns can be added to a CreateTable query
  4. The CreateTable query class now has constraints to a column. Examples of constraints are unique, not null, and default values
  5. The CreateTable query class now supports setting a column to be the Primary Key. The primary key is a column in the table that has to be unique and cannot be null
  6. Added an ignore flag to the Insert query. When the ignore flag is true, if there is an error the insert will not stop execution
  7. Insert queries now allow for adding booleans and undefined values
  8. Fixed issue causing sorts to be added to Find queries
  9. Added HasTable and GetLastInsertedID actions to the Database class. GetLastInsertedID will only work if an insert query has been executed before calling that action
  10. QueryResult now supports returning values as a boolean, number, and a DateTime object

User Interface Library Changes

The user interface library in Quorum has undergone major changes for Quorum 10. Notably, while the team has put in considerable effort on accessibility in screen readers, visual look and feel of the library has historically lagged behind. In this release, we have re-imagined the colors, borders, backgrounds, and many other small visual changes. Individually, many of these features are small, but overall they make a difference, we think, in terms of readability, usability, and accessibility. Further, because we want to ultimately have different versions for people with different visual needs and wants, we now include by default a light and dark mode in the system, which can be used in any Quorum generated user interface. Users can also create their own theme, with any visual properties and colors they wish, and apply them across the entire user interface system all at once. Detailed notes follow:

  1. Added a new shader for rendering controls in the user interface
  2. Refactored across many of the controls, providing some consistency across the rendering pipeline
  3. Added an InterfaceOptions class, which allows all user interface controls to reference standard colors and options
  4. Changed all of the major controls to coordinate with the InterfaceOptions class, allowing custom properties and colors to be more uniform everywhere
  5. Added Dark and Light modes for all user interface controls into the standard library
  6. Fixed a series of small bugs in the user controls where colors and options were hardcoded
  7. Added support for rounded corners to many controls
  8. Changed the default setting in tabs to use rounded corners
  9. Fixed a bug causing borders to look inconsistent in many controls
  10. Added a drop-shadow to modal dialogs so that that they look visually more like dialogs
  11. Re-imagined all of the default colors inside of the standard user interface controls. They should now be slightly easier to read and identify
  12. Adjusted colors and highlights to make the component that has the focus or the selection more visually obvious
  13. Added a screen reader feature equivalent to what is called roledescription on the web. This allows us to customize screen reader information in specific ways online. We observe not all screen readers read out the property by default
  14. Fixed a bug in tabbed panes where closing the last one on the left-most side would cause the rendered item to retain its rendering if a new item was auto-selected
  15. Added a drop-shadow feature to menus, pop-up menus, and dialogs

Mobile Changes

For this release, we added a series of default gesture detectors into all supported mobile platforms. These platforms do work slightly differently in regard to how they manage gestures, which ones they support, and other attributes, but Quorum now uses a system that standardizes these. For this release, while gestures are now available, they are not included in the default input sets for each control, as this would take some design work across the systems that is not yet complete. For example, charts, buttons, textboxes, trees, or other controls would likely benefit by having default gestures, but we need to figure out what those should be and write them consistently everywhere. Detailed notes follow:

  1. Added support for gestures to both Android and IOS devices
  2. Added gesture support into the InputSets, allowing any user interface control to add default gestures
  3. Gestures added:
    1. Single Tap
    2. Double Tap
    3. Long Press
    4. Pinch (Zooming)
    5. Pan
    6. Swipe
  4. Added vibration control into iOS mode

Quorum Studio Changes

Piggybacking on the new user interface changes in Quorum 10, Quorum Studio 4 incorporates these changes and makes a series of visual improvements. At a high-level, this includes a number of long-standing rasterization issues. Examples include issues with fonts, borders, and background colors, which sometimes were hard-coded around various interface controls in the standard library and in Quorum Studio. This significantly improves the look and feel of Quorum Studio, provides some user options, and slightly raises contrast in both modes. Detailed notes follow:

  1. Added light and dark mode
  2. Changed all of the icons in Quorum Studio to account for color modes
  3. Changed all of the icons and icon colors in the toolbar. They now can render at any resolution without obvious rasterization
  4. Added a new user preference for color mode in the Quorum Studio Properties dialog
  5. Fixed the splash screen so that it renders more sensibly at more zoom levels
  6. Conducted an accessibility pass and changed all of the colors for all modes. Broadly, the contrast is now higher and everything should be more readable
  7. Added in the most recent version of Awesome Font, which is used for rendering the toolbar
  8. Updated the project system to use the JSON reader in Quorum 10, which has slightly different rules for processing of arrays
  9. Keymaps are now versioned, due to changes in the InputSet system to account for gestures
  10. By default, if Quorum Studio loads with a keymap version less than 2, it destroys the file and resets to the default. The reason for this, while mildly annoying if the file is overridden, is that the codes are now calculated differently and not doing this would be much more confusing
  11. Fixed a bug in the about box causing it to not be accessible. Special thanks to Amanda Rodda for noticing this problem
  12. Significantly improved the check for updates window so that it, oh ... I don't know, actually tells you useful information about what it is doing. Previously, while it did technically update, if anything went wrong it twiddled its thumbs in unhelpful ways
  13. Removed the requirement to login to get updates from the update server
  14. Added a pop-up window when you try to close a number of tabs that were dirty, warning you that you may lose work
  15. Changed all of the colors and icons in the code completion window
  16. Fixed a bug in code completion causing the window to close with certain keypresses if there was no code completion options
  17. Made the code completion window generally less finicky as you type
  18. Added a new entry to code completion that tells you if there are no available options
  19. As always, changed some of the splash screen messages for no reason other than Stefik's personal amusement

Web Changes

For the web, we continued to work on making Quorum's web library more accessible and usable overall. We also updated the web library to include all of the features in Quorum 10, including shaders, light and dark mode, and other features. Detailed notes follow:

  1. Improved Shadow DOM support in the web libraries
  2. Changed the way focus is managed inside of the online development environments
  3. Changed Quorum's File class to more sensibly manage data from the web
  4. Added multiple file support to the development environment back-end. Technically, you cannot yet use multiple files in the environments, but all of the server side and database work is now completed
  5. Significantly optimized and updated Quorum's database backend on the live server
  6. Fixed several issues with font loading on the web
  7. Fixed the embedded development environments so they embed properly


For charts, our primary goal right now is in making the charting system more mature. Charts are quite complex visually and what methods make them as accessible as possible on each platform is a tricky question. At a high-level, we significantly improved the visuals, interactions, and flexibility of charts overall. We also squashed a considerable number of bugs in the chart system and improved how it renders itself to scalable vector graphics (SVG) files. Detailed notes follow:

  1. Added a regression line to scatter and line plots
  2. Added a trendline to the histograms
  3. Added the ability to use subtitles on charts
  4. Added use of 2 factors/1 column in box and violin plots
  5. Added annotations to bar/pie/scatter/and line charts. By default, the pie chart will show a (%) annotation, the other charts’ annotations can be shown using ShowAnnotations(true)
  6. Created a system for what is sometimes called a 'facet grid' in languages like R. This included separation by series, which separates the charts into subcharts by color/legend entry, and separate by factor, which separates the charts into subcharts by the factor used.
  7. Fixed a variety of issues in the SVG rendering of charts
    • Added viewbox settings to allow for scaling image size dynamically on the web
    • Update the LineChartWriter to use the ChartWriter parent class and updated accessible navigation
    • Added some basic XML escaping to the ToText actions in the SVG classes to fix issues with special characters (e.g., &, <, >, “)
  8. Reimagined accessibility in charts. We think there are quite a few more improvements that can be made, but also find the system much easier to use in a screen reader now
  9. Added borders and visual updates on many aspects of the charts to make them look visually nicer
  10. Fixed a number of small layout issues in charts
  11. Changed the selection of an item in bar charts and histograms to have a small arrow pointing at a bar instead of an outline.

Other Changes

  1. Fixed a bug in the compiler causing casting a value from text to a boolean to fail under some circumstances in JavaScript mode. It now correctly throws an error under these circumstances and a test case has been added
  2. Fixed a small bug in the compiler causing errors to be thrown as you type in Quorum Studio
  3. Fixed a bug in a JavaScript plugin that was incorrectly identifying a not a number as not a not a number. We have concluded that this line in our release notes is confusing, but fun to say and technically accurate, so we're keeping it
  4. Fixed an esoteric bug in the font system causing it to only accept font values in ASCII. Look, we were accidentally casting down in low level C to an 8-bit integer, ok?
  5. Fixed a nasty bug in JSON processing related to nested arrays. Unfortunately, this change is not backwards compatible and programs using JSON in Quorum 10 that make use of this feature will need to be updated
  6. Added a test case for a mildly complicated nested array in JSON

Quorum Studio 3.5 February 4, 2022

The overall technical architecture for Quorum Studio 4.0 and Quorum 10.0 is significantly different than in previous software releases on the project. In order to get adequate testing before the official release in the summer of 2022, we are putting up a middle of the road version of the technologies to make it easier for our team, and the community, to test everything. As this version of Quorum and Quorum Studio is about half-way between the next version, we are calling these versions Quorum Studio 3.5 and Quorum 9.5.

Graphics Shaders and Updates

For some time, Quorum has used OpenGL for rendering its content. Historically, because Quorum Studio was used across many school systems, we kept the OpenGL version rather old, as some schools use older hardware. Notably, we were using OpenGL 2.1, from 2006. While this system worked well enough to invent much of the accessible graphics pipeline in the language, OpenGL 2.1 used a particular kind of graphics pipeline that is now outdated. Further, OpenGL is having challenges today. Apple has deprecated this system, limits it to OpenGL 4.1 (about 2011 or so), and is quite slow compared to Windows in our testing. Further, OpenGL itself is sometimes being replaced by third parties (e.g., Apple's metal, Vulkan), while others still are maintaining it (e.g., WebGL, Android). The future of OpenGL is thus uncertain and we are preparing for the potential reality where its creators abandon it.

To try and fix this issue, we have redesigned Quorum's backend for Quorum 9.5. This includes the following changes:

  1. Upgrading to OpenGL 4.1 (desktop), OpenGLES 3.0 (mobile), or WebGL 2.0 (web). Despite the varying version numbers, these are all approximately the same OpenGL version for different platforms.
  2. Completed a near rewrite of the graphics system, exposing the raw shader system from within Quorum code.
  3. Added a set of raw graphics calls, which gives considerably more control of the graphics pipeline from within Quorum. These calls do largely map to OpenGL, but we have done our best to make them neutral across graphics pipelines. This will change in the future and we hope will become even more neutral over time.
  4. Added support for mapping calls into the graphics system, changing, and creating shaders. The idea is that you can set shaders on individual items or control them in a number of other ways.
  5. Added support for geometry and tesselation shaders from within Quorum.
  6. Currently, the shader code itself is written in GLSL. We strongly suspect this will change over time, because different platforms have different requirements. Further, even with these changes, writing shaders is difficult, and highly mathematical, so we suspect the team will be thinking of plans related to ease of use in the future as well. Point being, while users can use shaders now, we urge the community not to go nuts in creating GLSL specific dependencies.
  7. Adjusted and improved the graphics primitives that can be used on the system, including in the creation of a new polygon function from Drawable, which allows more sophisticated shapes to be drawn and also allows those shapes to be drawn with less pixelation.

Database Support (Beta)

Based on the work of Drews et al., we have implemented a new database system for Quorum. In this version, we consider this system to be in beta. The core approach behind this is described in the paper (the hybrid system, which happened to do best in the experiment) and allows users to write code to connect to, get data from, and send data to, a database system. In the first version, we support MySQL. For those needing different architectures (e.g., postgres), there is an architecture in place where it can be added, but such systems are not yet supported. Here are some of the core features of the system.

  1. Support for creating, adjusting, and dropping tables
  2. Support for logging into databases and closing them
  3. Support for many kinds of queries, written through typical Quorum syntax.
  4. Integration of database support into the data science systems, like charts, statistics, and DataFrames. This allows users to query databases and then run calculations on any results without needing custom programming languages or syntax.


As our work continues on Data Science for Quorum, we have made significant improvements to charts. There is a lot more work to do and how to tackle it is a balance. For example, charts need to look correct visually and, as those looks change, each piece needs to be made available in the accessibility system. Further, the charts need to be accessible online and offline and this means we need different modes for different purposes. Each of these features requires careful thinking and time. We expect many releases over the next few years on these features. Recent changes follow:

  1. Added a series of color templates that can be used. Many of the choices made by the team come from evidence in the academic literature [1,2,3], although so far as we can tell, there really is no perfect choice for the defaults. Thus, we have also given the user the ability to change between them, or set their own, as color needs are both partially subjective and vary, at least to a degree, by personal preference.
  2. Added the ability to split charts into facets, meaning separate them by factors from a DataFrame. Another way to say this might be to say that we can now automatically separate charts out by variables of interest.
  3. Adjusted a host of minor graphical changes to the charts to make them look visually nicer
  4. Added customization options for axes, legend position, font size, gridlines, group brackets, and point/line density.
  5. Added accessible navigation to charts exported as SVGs (bar chart, histogram, scatterplot, pie chart, violin plot). This work is complicated and a work in progress.
  6. Added support for additional Chart customization features in the SVG export process (visual update, gridlines, vertical/horizontal orientation, stacked/unstacked bars)
  7. Added pie charts and donut charts.
  8. Added a first step way to embed these charts into other systems accessibly.

Quorum Backend Changes

Quorum 9.5 introduces a rewritten backend for managing Quorum Plugins, through the integration of Gradle. For most users, this will not matter, but the key change is that when a user clicks build in Quorum Studio, what the language generates has changed a great deal. Thus, Quorum programs written in version 9.5 are source compatible with previous versions, and technically also generate the same bytecode from the compiler, but they interact with plugins differently. This change greatly simplifies how we connect into third party systems, including the iPhone, Android, and other features. Features include:

  1. Quorum now uses Gradle 7.1 from within the primary build system. Users overriding the standard library (rare for users to do), will now see different messages from the system.
  2. Changed QuorumStudio to use JDK 11 by default. The reason for this is, especially, because dependence on JDK 8 on Mac was preventing us from conducting experiments with accessibility on this operating system. Changing this was thus necessary to even begin work on Mac accessibility
  3. All plugin and Quorum code remains set to JDK 8 bytecode, not JDK 11, because otherwise it would break compatibility with LEGO mindstorms
  4. From Quorum, all plugins are now generated using projects in IntelliJ or the console. This allows users with accessibility needs to write the code in any accessible format they wish, then run the full build from within Quorum Studio or from the console, removing an additional accessibility barrier. This also removes our previous reliance on NetBeans.
  5. Fixed a number of small bugs in the compiler, especially related to the new parser architecture introduced in Quorum 9
  6. Fixed an extremely annoying bug in the compiler where parameters would not properly propagate their location information, which caused use hints to break and compiler errors to give the wrong location for essentially any error related to parameters
  7. Adjusted the standard library scripts to adjust how dependencies are managed, including how JavaScript is generated
  8. Quorum's test suite now uses NodeJS to execute

Code Completion

One major improvement in Quorum Studio 3.5 is code completion. While Quorum has had code completion for a while, it has generally been pretty buggy. With the advent of Quorum 9's hand parsing architecture, however, it became much easier for us to control what information can be sent to the code completion system, which in turn made it easier to rewrite it and clean it up. For this reason, code completion in this version is now much more reliable across the board. Some general changes include:

  1. Fixed a bug in code completion causing the return type to not show up properly
  2. Fixed a bug in code completion causing many kinds of expressions to not parse correctly and thus give you no information
  3. Added chaining to code completion. Not all permutations are yet supported, but the feature covers a significant number of common cases
  4. Significantly improved Quorum's ability to understand what would be useful to a user based upon context in the source
  5. Improved suggestions, including being able to provide hints for basic primitives, in addition to classes in the standard library, and action calls

iPhone Changes

Quorum has several changes to the iPhone architecture, including:

  1. The addition of Core Haptics to the supported APIs. The implementation is in beta and has not been well tested, but we are including it specifically so we can run experiments on it and improve it. The tricky part here is that we want calls on android for haptics to largely feel similar to those on iPhone, but we need to evaluate this using funky devices called laser doppler vibrometers. Also, laser doppler vibrometer is a fun thing to say. Go ahead. Say it 10 times fast. It's fun.
  2. Updated iPhone to the latest MobiVM release through Gradle
  3. Updated the Gradle support on iPhone to version 6.9. This is different than standard Quorum, but MobiVM does not yet support 7.1 and this version is sufficient for our needs
  4. Our iPhone support has historically had an extremely slow build process, due to the way we are building the native files and converting using MobiVM. This is still true, but we have introduced some primitive caching, which makes repeated builds faster. More work is needed on this system to speed up iPhone support in various contexts, but it is an improvement.
  5. Updated the graphics system to use the new shader architecture. We should note that due to inconsistencies in Apple's GLSL implementation on such devices, there are some continued challenges in graphics on such devices

Other Features

  1. Added a Serial class to Quorum for Serial port connections or bluetooth. Special thanks to Alex Chavez for the Pull Request for this feature
  2. Added a SerialPort class to allow communication on individual, but separate, ports.
  3. Added a way to query for available serial ports
  4. Made a host of improvements to the DateTime class, which badly needed the attention.
  5. Added support for dates into the DataFrame class

Quorum Website Upgrade

We have completed our long-planned upgrade to the Quorum website. This included a rewrite of a whole host of systems and an upgrade from Quorum 6 online to Quorum 9.5. Quorum can now be embedded into third party websites and run from anywhere. Finally, we have begun our experiments with making accessible graphics work in a web browser. This feature will take quite some time to get right, but we have been updating and tweaking the pieces since the initial update in December.

  1. Significantly changed the way you program on the website. This adds syntax highlighting, more hotkeys, and buttons.
  2. Added code regions that are still accessible, but visually look better
  3. Added code regions automatically in the generated documentation
  4. Changed to a new server infrastructure that should be much faster for most users
  5. Made the compiler an order of magnitude faster online
  6. Placed many of the compilation dependencies behind cloudflare, which should speed things up especially for international users
  7. Upgraded the online compiler to Quorum 9.5
  8. Made it so when you compile a program, you get immediate feedback, instead of jumping to a new page
  9. Integrated a graphics region in the online development environments so you can conduct graphics on the same page
  10. Upgraded the graphics system online to WebGL 2.0
  11. Fixed a host of small bugs in the online version of Quorum

Known Issues

We have completed our long-planned upgrade to the Quorum website. This included a rewrite of a whole host of systems and an upgrade from Quorum 6 online to Quorum 9.5. Quorum can now be embedded into third party websites and run from anywhere. Finally, we have begun our experiments with making accessible graphics work in a web browser. This feature will take quite some time to get right, but we have been updating and tweaking the pieces since the initial update in December.

  1. Xcode 13 removed xtrace from the xcrun utility, which means our ability to detect iOS devices is currently broken in that version. This is true for older and newer versions of Quorum Studio
  2. Certain graphics applications seem to be throwing an error on M1 mac processors. The error does not appear to impact runtime behavior


  1. Gramazio, C. C., Laidlaw, D. H., & Schloss, K. B. (2017). Colorgorical: Creating discriminable and preferable color palettes for information visualization. IEEE Transactions on Visualization and Computer Graphics, 23(1), 521-530. https://doi.org/10.1109/TVCG.2016.2598918
  2. Lyn Bartram, Abhisekh Patra, and Maureen Stone. 2017. Affective Color in Visualization. In Proceedings of the 2017 CHI Conference on Human Factors in Computing Systems (CHI '17). Association for Computing Machinery, New York, NY, USA, 1364-1374. DOI:https://doi.org/10.1145/3025453.3026041
  3. Luz Rello and Jeffrey P. Bigham. 2017. Good Background Colors for Readers: A Study of People with and without Dyslexia. In Proceedings of the 19th International ACM SIGACCESS Conference on Computers and Accessibility (ASSETS '17). Association for Computing Machinery, New York, NY, USA, 72-80. DOI:https://doi.org/10.1145/3132525.3132546

Quorum Studio 3.0.1 September 10th, 2021

This is a small bug fix release. Notes follow:

  1. Fixed a bug causing the 2D palette in Quorum Studio to break. Special thanks to Ko Inamura for the bug report.
  2. Fixed an infuriating bug that caused the toolbar to disappear sometimes when a scrollable table was active.
  3. Fixed a bug causing the layout of a table to twitch and wrap incorrectly on even small resizing changes.
  4. Fixed a bug causing tables to crash when using screen readers in certain circumstances.
  5. Fixed an issue which could cause textboxes to crash with a screen reader active when deleting text near the end of a file.
  6. Fixed a bug causing Quorum Studio to not properly update the icon in the tree when you set a file as the main file. It now correctly changes the color.

Quorum Studio 3.0 and Quorum 9.0 July 9th, 2021

Quorum Studio 3.0 and Quorum 9.0 are the next major upgrades for developing in the Quorum Programming Language. Unlike previous years, we rolled out many crucial additions and features throughout the year. The changes here focus on those made since the last minor update, which was in Quorum Studio 2.3. Note that some of these notes are duplicative of the notes that were emailed to the community, but not put on the website, for Quorum Studio 2.5. We wanted to get beta versions of this material out to the broader community early for feedback and review, given how extensive they are. Thus these notes here include changes from Quorum Studio 2.5 through 3.0.

Android and iOS support

Following the revival of Android Support to Quorum in Quorum Studio 2.3, we have additionally added support for iOS devices. Quorum originally had primitive iOS support in an older version, but this was dropped because the product, RoboVM, that Quorum depended on was discontinued. One group, MobiVM, created an alternative and really knocked it out of the park. We have adapted our content to use MobiVM, starting nearly from scratch on how this system is put together. We would especially like to thank Nicholas Vancise for his contribution to the iOS system in Quorum, which we largely copied from his Github repository. That is available on github: https://github.com/thenick775/Quorum_iOS_Transpiliation/. Note that we included this support in the Quorum Studio 2.5 release. This feature is unchanged in 3.0.

3D Support in the Quorum Studio Scene Editor

New in Quorum Studio 3.0, we now have support for 3D in the scene editor. This system, which is accessible, allows us to create 3D items, like models, primitive cubes, and other shapes, when creating games. Like 2D, it uses a very similar system for accessibility, with similar property windows, and other attributes. These changes are now integrated into scene files, so it is backward compatible. However, note that Quorum Studio 3.0 scene files, because they add 3D, require 3.0 or above. We have attempted to make keypresses, navigation, and interaction mimic the 2D system as much as we can, but as always would appreciate feedback as we decide on how to expand the scene system for future releases. Note that a beta version of this feature was placed into Quorum Studio 2.5. Changes since this release include:

  1. Fixes to a series of hotkeys
  2. Adjustments to the auditory cues made inside screen readers
  3. Added a function to the Matrix4 class to simplify transforms, TransformWorldCoordinate. The TransformWorldCoordinate action takes a 3D point in space (e.g., the location of an Item3D) and applies any movement, rotation, or scaling that's stored in the Matrix4 to that point.
  4. Simplified scaling and rotation by storing values for them instead of shoving them in a transform. This was a significant usability issue that made the scene editor hard and the programming hard to use.
  5. Changed the palette to include lighting
  6. Added a way to add your own models and sounds into the 3d scene editor

New Quorum Parser

Quorum 9.0 includes a brand new parser technology, which replaces our beloved Antlr as a parsing stack. While we love Antlr and it has made Quorum possible for many years, recent evidence from Becker et. alamongst others, has shown strong evidence that the design of compiler error messages needs improvement. This problem is not unique to Quorum, but neither is Quorum exempt from this evidence.

This technology provides three big advantages. First, we can control every compiler error message directly, without needing to go through Antlr. Second, this technology can cross-compile itself to the web, which should allow us to improve our web-stack for Quorum over time. Finally, this new technology has been integrated into the standard library and allows us considerably more control over parsing in the language. We suspect that these error messages, and this technology, will be iterated on for several years as we talk to users and collaborate with the research community.

While we conducted an edit pass on error messages in Quorum Studio 2.5, we did a second pass for 3.0 through all aspects of the compiler. Thus, users will observe new messages across the board. Further, since Quorum Studio 2.5, we have additionally conducted the following changes to our new parser's beta phase:

  1. Using the Flesh-Kincaid metric, we examined every compiler error message in the parser, bringing many of them down from college reading level to approximately 8th grade reading level. Many of these messages could not easily be lowered further without making the meaning of the error message incorrect.
  2. Evidence from Daleidens's dissertation showed approximately 70% of compiler errors for Quorum online come from the parser. As such, we've heavily modified the compiler error messages for these errors a second pass. We suspect, as more evidence is gathered, they will be changed further.
  3. Did a general edit pass on all error messages, including old ones and rare ones that might occur during semantic analysis.
  4. Fixed a bug in the compiler that could, on rare circumstances, cause it to enter an infinite loop if there was exactly the right kind of compiler error in exactly the right kind of spot.
  5. Fixed a bug in the compiler that would sometimes cause an exception to be thrown in certain kinds of solo action calls.
  6. Fixed a bug in the parser that would cause the system to ignore certain kinds of errors related to incorrect expressions. These kinds of errors now correctly state the problem and provide correct locality.
  7. Fixed several files in the compiler that were not in the correct folder. Quorum doesn't actually care, but the standard library generator was angry about it.
  8. Fixed a nasty bug in the new parser, which was allowing solo action or parent action calls to be triggered in field blocks. This was intended to be a compiler error and was one in Quorum 8. It has been put back into a compiler error.

Scientific Notation

Given the Quorum 9 change to a new parser, we took the opportunity to make a few minor adjustments to the programming language that are long-standing. The most significant is in the addition of scientific notation. Notably, while we normally like to collect evidence on changes before making syntax changes, we observed that our data science system was excruciatingly frustrating to use without scientific notation. This notation is largely standardized internationally, so we decided to adopt it. Thus, we designed a system that looks like so:


In the current design, we use standard symbols for scientific notation, with the exception that the e must be lowercase. The reason for this is because of Bonita Sharif's excellent work on readability of code with eye trackers. In discussions, the lower-case e provides a natural separation point compared to the upper case, which we suspect matches her results better than allowing the capital E. Note that scientific notation is allowed only for numbers, but not integers. Future evidence may cause us to alter this design, but given this is a standard that is often taught in schools and used on calculators, we think it is reasonable.

Quorum Online Changes

In Quorum 9, we have made major changes to how Quorum outputs JavaScript when it compiles. This feature, likely not well known in the community, is how Quorum allows itself to run online. Notably, we now pre-compile the Quorum 9 standard library and cache it online, sending back only the minimal set of code for each request. This dramatically, and we mean dramatically, increases the speed at which Quorum can issue requests online.

The broad approach here, given that a number of partners use Quorum online in different ways, will take time to push online, as for it to go live we need to work with our partners and ensure we don't break their work. As such, while these changes are available today, they will not be on the live server until a later date. These changes broadly include the following:

  1. Quorum's standard library is now pre-compiled, like it is on desktop, and this is cached in the browser.
  2. Quorum's online development environments no longer need to go to a separate page.
  3. The speed at which the compiler can issue requests has been dramatically increased.
  4. Quorum now includes a web server mode, replacing our old tomcat server, which allows it to send JavaScript conversion requests over the wire. While this server is general and can technically be used for anything, the implementation is primitive and we urge caution in using it in production environments.
  5. Adjusted how Quorum outputs JavaScript to account for a myriad of changes between Quorum 6 and 9. These changes are not backwards compatible, but should require minimal change to get working.
  6. Quorum's online development environments now include an embedded graphics canvas.
  7. Included font support into the default graphics canvas.
  8. Updated the website in most locations to use the new development environment.
  9. Added development environments to pages previously without one. This expands what can be done online considerably.
  10. Split up the drawing 2D tutorial into 3 separate tutorials. They now have development environments in them as well.
  11. Split up the events tutorial into 4 separate tutorials.
  12. Reorganized the reference page and split up the games tutorials into a larger series of tracks for particular sub-topics.

Tooling Changes

To account for changes to Quorum 9, the debugger and the code completion system have been significantly changed. Major highlights include speed increases in both systems, improvements to readability, and a series of general bug fixes. Stepping over code is now much faster and code completion, at least on our test systems, pops up near instantly. The full list includes:

  1. Fixed a bug in the debugger where the variables window would not properly indent when resized
  2. Fixed a bug causing the debugger to execute slowly if any of the stepping keys were pressed, using any input modality
  3. Fixed a bug causing breakpoints to not be properly sent to the debugger if it was already running
  4. Fixed a bug causing the debugger line to not show up properly if other highlight lines were at the same position
  5. Fixed a bug causing the debugger line to disappear in certain circumstances
  6. Fixed a bug causing the debugger line to disappear in the standard library in certain circumstances
  7. Added a way to prioritize highlight lines into the textbox renderer. This ensures certain lines are always "on top" visually when rendered. Any Quorum application can now set these priorities in a textbox.
  8. Updated the tools dependency in the debugger to a more modern version.
  9. Replaced the code completion system with one generated by the new parser architecture. In this first version, it is limited, but this approach provides us a much more powerful way to estimate the likely request being sent by the user. The current version is primitive, but still seems to work better than the old system.
  10. Significantly improved the speed in which code completion finishes collecting information
  11. Added a new parse listener architecture for code completion, based on Quorum 9's infrastructure. This greatly simplifies changing the code completion system in the future.
  12. Fixed a bug causing COMMAND or CTRL + J to not work correctly in standard library files.
  13. Fixed a bug causing git annotations to not show up in standard library files
  14. Fixed a bug causing spurious editor hints and compiler errors to show up in standard library files
  15. Quorum Studio now generates a log file for technical errors. This information now records errors thrown by the system as you code. This information is stored locally only and is not sent to the Quorum team, but provides us much more information about what happens in the field with Quorum Studio if a user runs into trouble.
  16. Fixed a bug in code completion causing it to crash under certain circumstances.
  17. Fixed a bug in the compiler error window that made it difficult to read the errors, as they were cropped.
  18. Fixed a bug where tabbed interfaces would require the user to click on the tab, click off the tab, then click back onto it for it to show up correctly. We did not like this bug. It was not very nice.
  19. Fixed a bug where tables could not word wrap properly. This made compiler errors in Quorum Studio very difficult to read.
  20. Fixed a bug in trees, radio buttons, and the spreadsheet, where the selection would not show up visually until user interaction had happened. Ironically, this was always working for screen reader users, just not people that can see.
  21. Fixed a bug on Windows where if you did an auto-update on a version of Quorum Studio where the standard library had a name or package change on a file, and installed over the system, it would double up on the refactored portions of the standard library.

Data Science Changes

Quorum Studio 3.0 and Quorum 9.0 includes a considerable number of improvements to the new Data Science libraries in Quorum. Many minor changes are listed below, but overall we have significantly improved the naming conventions, talked to users of the API on their needs and how they use it, and re-tooled the entire system. Additionally, we conducted a randomized controlled trial on how to do operations like filtering, which ultimately showed that we can serve user's needs by embedding a small domain specific language inside of Quorum, which is for filtering. The rules are the same as Quorum, but the broad idea is that we can conduct simple filtering operations in DataFrame objects without using the Transform system.

  1. Changed the name of TDistribution to HeavyTailNormalDistribution
  2. Changed the name of FDistribution to VarianceRatioDistribution
  3. Changed the name of CompareColumnToMean to CompareGroupToMean.
  4. Updated CompareColumnToMean to naming conventions that have been adopted consistently across all statistical tests
  5. Added a few Univariate actions for inverse computations and a parent class.
  6. Removed the CompareTwoColumns class, which has been replaced with the more general CompareGroups class.
  7. Added a RootFinder class, equivalent to a Brent function.
  8. Added a Continued Fraction for Gamma distributions
  9. Added a class for calculating the mathematical ErrorFunction, called ErrorAction in quorum.
  10. Added several helpers to the Gamma class from Apache Commons
  11. Added a class for Normal distributions
  12. Fixed a bug in the T Distribution (now HeavyTailNormalDistribution), which caused it to make incorrect calculations as the degrees of freedom approaches infinity. Alternative algorithms need to be investigated for exact values, but it is very close as it is and matches the bug fix in Apache Commons.
  13. Added a result called CompareGroupsResult, which gets information back from anova calculations and pairwise calculations.
  14. Added pairwise tests and optional Bonferroni calculations into the default CompareGroups class.
  15. Added a CompareVariances class, which is equivalent to a Levene's test
  16. Added a CorrelateGroups class, which is equivalent to a Pearson correlation
  17. Added a CorrelateRanks class, which is equivalent to a Spearman correlation. Note that Spearman correlations are really just a rank transform followed by a Pearson. Because Kendall's tau gives a similar result, only this approach is supported in the standard library in the current version.
  18. Modified the regression and other classes to the new naming conventions for distributions.
  19. Renamed a number of actions inside the classes for consistency. This includes renaming some of the probability functions to CumulativeDistribution, which matches more common statistical terminology.
  20. Added survival, inverse survival, and inverse cumulative distribution actions to the distributions
  21. Added a NumberDistribution class to standardize actions across subclasses. We suspect these will grow over time as we flesh out the library, and as such, we want to keep them consistent. While the design comes from Apache Commons, we imagine it will diverge over time as we better learn what naming conventions and designs make sense for people in practice.
  22. Fixed a bug causing line feed/new line combinations to fail in reading csv files.
  23. Fixed a bug causing the last character of csv files to not be properly read
  24. Improved the efficiency of the CSV file reader, significantly boosting its speed for large data sets (tested in the 100MB range).
  25. Fixed a bug in charts causing the last row to crash
  26. Added line charts with multiple lines and violin plots. Special thanks to Gabriel Contreras, Cody Molisee, and David Van Hack for doing this work
  27. Added Scalable Vector Graphic support to charts, so they can be stored to disk.
  28. Added a series of windowing functions (kernel functions) for use in Violin Charts
  29. Modified DataFrame to account for line charts and violin charts as part of the selection system.
  30. Added extra Copy operations to the DataFrameColumns to make it easier to Copy and Sort unique items
  31. Added a CrossTab action to DataFrame, which creates a CrossTab DataFrame from two column selections
  32. Added a CrossTab Transform class that can calculate the CrossTab Transform to a copy of the DataFrame.
  33. Fixed an issue with ScatterPlot to cause it to not respect the ColumnInput selections commonly used amongst all charts and graphs
  34. Updated documentation for ScatterPlot to indicate the changes.
  35. Fixed an issue with several files in the standard library having incorrect packages.
  36. Fixed an issue where CumulativeDistributionAction was misspelled CulumativeDistributionAction in the class name. The standard library scanner was displeased.
  37. Moved StatisticsFormatting to the Libraries.Compute.Statistics.Reporting package.
  38. Added a multi-column sort function to DataFrame
  39. Fixed some of the usability and visuals of Legends
  40. Added input options for multiple columns, one factor and two factors in bar charts and histograms
  41. Added Bar and BarGroups to allow for unstacked BarCharts
  42. Updated the accessibility navigation and text in bar charts and histograms
  43. Added input options for multiple columns, one factor or no factors in line charts
  44. Added text or numerical factor data in line charts
  45. Made some introductory improvements to line density in line charts, although this needs more work.
  46. Added input options for multiple columns, first column defaults to x-axis in scatterplots
  47. Added text or numerical for all data in scatterplots

Accessibility Changes

  1. Fixed a bug where selecting to the beginning of the line would select white space when it wasn't supposed to using SHIFT + HOME
  2. Added first letter navigation for several components, includings trees, lists, and tree tables
  3. Added a property in Quorum Studio to adjust the type ahead speed
  4. Added the ability to adjust the first letter navigation speed inside of the game class. This allows people with disabilities a way to control the speed of type ahead in controls
  5. Added menu mnemonics and the ability to change them in the standard library
  6. Added Mnemonics to Quorum Studio's menus
  7. Added the numpad enter key for certain operations

General Bug Fixes/Changes

  1. Fixed a strange bug in file writing where if you tried to append to a file, it would append to the wrong location under certain circumstances.
  2. While we had a temporary hotfix previously, we have officially added support for Big Sur into Quorum and Quorum Studio.
  3. Refactored Font loading to remove a strange loading procedure that was causing operating system compatibility problems.
  4. Changed Labels so they do not try to load a font in their constructor. Now, if GetFont is called, and no font has been loaded, Label chooses a sensible default. This change allows you to change the default Font loading directories for custom operating system or application installs.
  5. Fixed a bug in code completion that caused a crash under strange circumstances
  6. Fixed a bug causing Quorum Studio to not properly log a crash under various circumstances
  7. Fixed a bug in Quorum Studio causing it to set a main file to a non-quorum file. This was, uh, bad, and not at all what it was supposed to be doing. Children were sad and garden gnomes took over. It's fixed now, Rory and Michael. Special thanks to Amanda too.
  8. Reduced the size of the standard plugins in the standard library by 20.7% by removing dependencies related to Antlr.
  9. Added a new action called GetSecondsSinceStart, which allows the user to request how long it has been since the game was created.
  10. Fixed a long-standing bug in the graphics system causing interface components in a 2D layer to sometimes appear "blurry." This rather annoying bug would show up especially on non-high res monitors or under certain kinds of screen and zoom resolutions and was especially common on Windows. Any component should now be slightly crisper, but font rendering especially has been considerably improved.

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: