Skip to main content

v1.8

1.8.4​

This release fixes problems in audio output, Audio Worklet playback, triplet feel and rendering on .NET.

Player​

  • player: on Android, the audio output no longer spins the CPU at the end of playback, and the C# and Kotlin outputs no longer allocate buffers while playing (#2715, thanks @xyfu66)
  • player: a second playback with the Audio Worklet output no longer replays events buffered for the previous worklet (#2764, thanks @gisenberg)
  • player: triplet feel pairs the right beats again, which removes odd note durations and a flickering cursor (#2765)

Improvements & Bugfixes​

  • render: .NET on Mono no longer fails with "Collection was modified" during rendering (#2766, thanks @dawidprosba)

1.8.3​

This release adds labels for hammer-ons, pull-offs and slides, incremental re-rendering for apps that change the score while it is displayed, and limits that protect against corrupt or crafted input files.

Music Notation​

notation: hammer-on, pull-off and slide labels​

https://github.com/CoderLine/alphaTab/pull/2609

alphaTab writes "H" on hammer-on arcs, "P" on pull-off arcs and "sl." on legato slides, in standard notation and tablature. A chain like 5{h} 7{h} 5 is drawn as an H arc followed by a P arc.

\staff {score tabs}
:8 5.3{h} 7.3{h} 5.3 7.3{sl} 9.3 r r r

The labels are shown by default. Hide them by turning off NotationElement.EffectHammerOnPullOffText or NotationElement.EffectSlideText in notation.elements. Their font is set through display.resources.elementFonts.

Since 1.9, the labels sit above the staff, which is how the sample above renders on this site. See Slides, hammer-ons, and pull-offs.

Thanks to @rafaelsales for contributing this improvement.

render: incremental re-rendering for live editing and recording apps​

https://github.com/CoderLine/alphaTab/pull/2585

Recording apps and live editors change one bar at a time, often while the player drives the cursor. A full render lays out the whole score again for each change. Pass the index of the first changed master bar as firstChangedMasterBar in the render hints, and alphaTab keeps the systems before that bar and lays out only the rest.

The render hints are accepted by api.render(renderHints), api.renderScore(score, trackIndexes, renderHints) and api.renderTracks(tracks, renderHints). They affect rendering only: call api.loadMidiForScore() to update playback. The incremental path applies to the page and parchment layouts while core.enableLazyLoading is on (the default). The horizontal layout, and a bar index outside the rendered systems, fall back to a full render. When you append bars, pass the index of the last bar that was already rendered.

import * as alphaTab from '@coderline/alphatab';

const api = new alphaTab.AlphaTabApi(document.getElementById('alphaTab'));
api.tex(':4 5.3 7.3 5.3 7.3 | 5.3 7.3 5.3 7.3 | 5.3 7.3 5.3 7.3 | 5.3 7.3 5.3 7.3');

// Move every note of the third bar to fret 9 and redraw from that bar on.
document.getElementById('edit-bar').addEventListener('click', () => {
  const barIndex = 2;
  const bar = api.score.tracks[0].staves[0].bars[barIndex];
  for (const voice of bar.voices) {
    for (const beat of voice.beats) {
      for (const note of beat.notes) {
        note.fret = 9;
      }
    }
  }
  bar.finish(api.settings);

  api.render({ firstChangedMasterBar: barIndex, reuseViewport: true });
  api.loadMidiForScore();
});

The same change makes the rhythmic spacing within a staff more consistent, allows seeking to empty beats, and updates the cursor when a bar changes its height. See Re-render only what changed.

Thanks to @roscopeeco for describing this use case in #2560.

Player​

  • player: swing and shuffle feel no longer break playback ranges, seeking, hit testing and cursor placement (#2702, thanks @AvaTheArchitect)
  • player: api.playBeat() and api.playNote() are audible once api.isReadyForPlayback is true (#2708, thanks @Buronn)

MusicXML Extensions​

  • importer: pitched percussion notes keep their articulation when <instrument> is omitted (#2701, thanks @alustrement for this first contribution)

Guitar Pro Extensions​

  • importer: Guitar Pro 7 and 8 files with tempo automations on missing bars load instead of crashing (#2668, thanks @kaizenman for contributing this fix)
  • importer: artificial harmonics in Guitar Pro 3–5 files are imported with their harmonic values (#2707)

importer: hardened file loading​

https://github.com/CoderLine/alphaTab/pull/2703 https://github.com/CoderLine/alphaTab/pull/2669

Corrupt or crafted files could make alphaTab run out of memory or read endlessly: unbounded counts in Guitar Pro bend and tremolo bar data, oversized strings, chord names longer than their field in Guitar Pro 3–5 files, and zip bombs. alphaTab now caps buffer sizes when it decodes strings and inflates zip archives. It also bounds the count-driven loops of the Guitar Pro 3–5 parser, reads chord names at their fixed field width, and stops when the data ends.

The cap is set by importer.maxDecodingBufferSize, 128000000 bytes by default. Raise it if you load very large files. Files that exceed a limit fail with an OverflowError, files that end early with an EndOfReaderError. Both are AlphaTabErrors of type Format. See Tuning importer behavior.

Thanks to @kaizenman for reporting these problems and contributing the chord name fix.

Improvements & Bugfixes​

1.8.2​

This release moves .NET and Android to the threading model of the web version and fixes playback at the end of songs and loops.

Player​

  • player: the cursor lines up with the notes again; since 1.8.1 it could drift because it used a time-relative position (#2573, thanks @louislam)
  • player: Audio Worklet playback no longer freezes when samples arrive before the worklet is created (#2645, thanks @gisenberg)
  • player: a track on MIDI channel 16 keeps its audio when the metronome is on; the metronome uses its own channel (#2651, thanks @reifocS)

player: faster stop at the end of songs and loops​

https://github.com/CoderLine/alphaTab/pull/2647

Playback could hang or hiccup at the end of a song or loop. Voices that were no longer audible kept generating samples, and the end was detected only after the output had played its buffered audio. alphaTab now ends voices once they become inaudible, and stops all voices quickly as soon as sample generation reaches the end.

Thanks to @AvaTheArchitect for reporting this problem.

MusicXML Extensions​

  • render: on Android, MusicXML files that rendered only partly and broke the cursor render completely; the fix covers an empty initial render, dots on hidden notes and tuplet numbers above 19 (#2650, thanks @AndreiGorelov)

Guitar Pro Extensions​

  • importer: harmonic types are parsed case-insensitively, so harmonics in files written by third-party apps such as Songsterr load (#2648, thanks @sandrojologua)

Improvements & Bugfixes​

  • web: several alphaTab instances on one page no longer fail with TypeError: Cannot read properties of undefined (reading 'length') (#2574, thanks @tbreuss)
  • integration: the selection highlight is recreated after a resize or re-render instead of keeping stale bounds (#2646, thanks @gisenberg)

platform: one threading model on all platforms​

https://github.com/CoderLine/alphaTab/pull/2644 https://github.com/CoderLine/alphaTab/pull/2649 https://github.com/CoderLine/alphaTab/pull/2652

On .NET and Android, alphaTab used a threading model that differed from the web version. This caused race conditions: a null reference in the cursor update, "Animation duration cannot be negative", a ConcurrentModificationException during layout, a memory leak in the synthesizer worker and an InterruptedException in the audio worker. All platforms now use one UI thread plus one thread per worker, sharing the web code. Rendering with Skia runs off the UI thread; it was wrongly marked as incompatible with workers. On Android, the audio worker handles interrupts correctly and workers no longer leak when the activity changes.

Two extension points change with this:

  • Custom UI facades implement the new member IUiFacade.throttle(action, delay). It takes over from Environment.throttle.
  • Custom bundler integrations: the worker factory passed to Environment.initializeMain receives a second argument, nameHint ("alphaTab Renderer" or "alphaSynth Worker"), which you can use as the worker name.

Thanks to @AndreiGorelov for reporting these problems.

1.8.1​

This hotfix release brings following improvements

Music Notation​

render: respect diatonic scales for note placement​

https://github.com/CoderLine/alphaTab/pull/2534

Up to this release alphaTab had rather a "chromatic spelling" when it comes to placing note heads and accidentals. This means it simply looked at the octave and applied accidentals accordingly where needed. This leads to non-optimal display of notes in various key signatures.

e.g. For a F# key signature we would show a F-note with a naturalize accidental instead of a E# note without any accidental (the # is applied via key signature).

\title "F# Major Scale"
\ks f#
\tuning (G2 D2 A1 E1)
\clef bass
:4
2.4 4.4 1.3 2.3 | 
4.3 1.2 3.2 4.2 | 
4.2 3.2 1.2 4.3 |
2.3 1.3 4.4 2.4

Thanks to @tbreuss for reporting this problem.

Guitar Pro extensions​

importer: correct GP5 bass clef detection (Guitar Pro 3-5)​

https://github.com/CoderLine/alphaTab/pull/2531

The improvements for detecting bass clefs in GP5 files caused a strange bug where we treated almost all files with a bass clef. This fix ensures the correct behavior.

importer: handle all Guitar Pro 5 percussion instruments​

https://github.com/CoderLine/alphaTab/pull/2537

As we updated the percussion handling 1.8.0 there broke some compatibility things with Guitar Pro 5. The latest Guitar Pro versions do not support all percussion instruments which existed in Guitar Pro 5 and alphaTab inherited that problem.

We added some workarounds to ensure we are compatible with these special percussion instruments. The affected instruments are mainly part of the "General Sound" MIDI standard and cover some rather rarely used instruments.

We map unsupported articulations to known ones and also handle fallback scenarios better.

Thanks @LIUBINfighter for reporting this problem.

Player​

player: animate cursor to playback range end​

https://github.com/CoderLine/alphaTab/pull/2536

This is a small improvement in the cursor animation for alphaTab. Unless there are some repeats or jumps, the beat cursor typically animates from the start beat to the next beat. But if users select a part of the song to be played or the playback range is set via code, the cursor visually exceeds the selected range.

While technically it is not wrong to indicate that the playback reaches over to the next beat, it looks rather wrong from a UI/UX perspective.

With this improvement the cursor will now animate to the end of the selected beat in such cases.

Thanks @AvaTheArchitect for reporting this problem.

player: allow custom cursor handlers​

https://github.com/CoderLine/alphaTab/pull/2536

As part of the cursor animation improvements we also added the possibility to handle the cursor placement in a custom way. This extension point is similar to the IScrollHandlers we added (see below). The new ICursorHandler which can be set via api.customCursorHandler allows custom placing of the bar and beat cursor. It is currently tightly coupled to the way alphaTab handles the cursor placement.

If you are implementing a custom extended cursor (e.g. with more complex UI elements) you can now handle all the placement and animation logic in a custom implementation. You can start your own implementation by looking at our default implementations in the alphaTex codebase and work your way from there.

Likely this API still needs some fine-tuning and extensions, but considering this is a patch release, it should allow handling most important bits.

1.8.0​

This has been one of the fastest alphaTab releases so far. Within 1 month we added quite a list of improvements and fixes. Let's dive in. 🤘😎

Music Notation​

notation: extend bar-lines across staves in system​

https://github.com/CoderLine/alphaTab/pull/2416

This new option allows extending the bar lines across the staves in the system connecting them for better visual guidance. We also respect the related Guitar Pro stylesheet settings or the option can be set via alphaTex or on the stylesheet object after loading the files.

This feature can be configured via:

notation: multi-system slurs​

https://github.com/CoderLine/alphaTab/pull/2425

Previously alphaTab only rendered slurs on single-system breaks. If a slur spans multiple systems this caused an incorrect display. With this improvement we can now have slurs spanning many systems until the end bar is reached.

The alignment of these slurs has been improved to resemble the height at the starting system.

notation: improved note head alignment and displacement.​

https://github.com/CoderLine/alphaTab/pull/2426

https://github.com/CoderLine/alphaTab/pull/2430

With this change we now align note heads according to more common practices.

The first change is to align the primary note heads on the same axis. Basically: on an upwards stem the left note heads, and on a downwards stem the right note heads are now aligned. Displaced note-heads are shifted to the other side of the stem.

With this improvement as a base, we now also merge or further shift note-heads when multiple voices are contained in a bar. This way the readability is improved and unnecessary white-space is avoided.

notation: in-score chord diagrams​

https://github.com/CoderLine/alphaTab/pull/2435

Often requested but never shipped. Now they are available: chord diagrams inside the music sheet.

Previously alphaTab could only show the used chord as diagrams on top of the score. With this change chord diagrams can be shown inside the music sheet above the staff.

notation: numbered notation ties and dash placement​

https://github.com/CoderLine/alphaTab/pull/2438

alphaTab 1.7 had some incorrect display of numbered notation. Following improvements were added in this release:

  • The beats are now correctly showing the respective duration with dashes and additional number glyphs as expected.
  • The dots and overflow calculations have been reworked to avoid overlaps
  • The "beam" drawing logic has been updated to be closer to the common logic.
  • We do not render beams for grace notes anymore.
  • key signature has been moved to an own effect band.

notation: hide empty staves​

https://github.com/CoderLine/alphaTab/pull/2443

With this feature we add an option to hide staves if they are empty. This feature mainly targets the multi-track display and multi-staff instruments. If the option is configured, any staves without content will be hidden.

At this point alphaTab will not hide whole systems to avoid side-effects during playback and the related cursor placement. If alphaTab detects tha all systems are empty, it will force the first one to be visible.

This feature can be configured via:

notation: parchment layout​

https://github.com/CoderLine/alphaTab/pull/2459

The parchment layout is is a variation of the currently available page layout. THe special thing about this layout is that the configured systems layout is always active. For the page layout a separate option was required to enable the usage of the systems layout which configures the number of bars shown in every system.

The parchment layout is typically more optimized for printing and fixed layouts where the exact positioning and sizing of elements is important.

\track {systemslayout (2 3 2)}
  \scale 2 C4 * 4 |
  \scale 1 C4 * 4 |
  \scale 2 C4 * 4 |
  \scale 1 C4 * 4 |
  \scale 2 C4 * 4 |
  \scale 0.5 C4 * 4 |
  \scale 1 C4 * 4 |

This feature can be configured via:

notation: buzzroll tremolos​

https://github.com/CoderLine/alphaTab/pull/2476

With this change we now support buzzroll tremolos. It can be separately configured if these tremolos should be played like classical ones.

:4
C4 {tp 1} |
C4 {tp 2} |
C4 {tp 3} |
C4 {tp (3 buzzRoll)} |

BuzzRolls can be used via:

  • tp on alphaTex
  • MusicXML using tremolo marks 0 or setting the smufl attribute.

style: advanced font configurations and lyric paddings​

https://github.com/CoderLine/alphaTab/pull/2481

This improvement changes extends how fonts can be configured in alphaTab. Previously the settings.display.resources had specific properties for individual items lacking flexibility for a range of elements.

With this change devs can now configure fonts for a wide range of individual NotationElement.* values. The old general effectFont was deprecated and fonts can now be configured individually as desired.

This feature started with a request to customize the display of lyrics. To support this request further, the padding between individual lyric lines can now be configured via settings.display.lyricLinesPaddingBetween

This feature can be configured via:

notation: configure display of bar numbers​

https://github.com/CoderLine/alphaTab/pull/2482

Before this release alphaTab was always rendering bar numbers on all bars. Devs could trick the display by setting the bar number color but this was not really a sustainable approach.

With this feature it can now be configured whether to show bar numbers on

  1. all bars
  2. no bars
  3. the first bars of every system

We now read the respective information from supported input formats (Guitar Pro, MusicXML, alphaTex) to respect the intentions of the transcriber.

\defaultBarNumberDisplay firstOfSystem 
C4.1 | C4.1 | C4.1 | 
C4.1 | C4.1 | C4.1
\defaultBarNumberDisplay hide 
C4.1 | \barNumberDisplay allBars C4.1 | C4.1 | 
C4.1 | C4.1 | C4.1

This feature can be used via:

notation: custom beaming rules​

https://github.com/CoderLine/alphaTab/pull/2489

alphaTab 1.8 ships significant improvements around the beaming of notes. Previously alphaTab had only 2 rules on how notes were beamed.

With alphaTab 1.8 not only we have 27 optimized beaming rules for a range of common time signatures. Users can now fully customize how notes should be beamed.

We read the information contained in Guitar Pro files and alphaTex provides new metadata tags for this feature. In worst case devs can opt to set the rules after loading any custom file.

\ts (4 4)
\beaming (8 2 2 2 2)
  C4.8 * 8 |
\beaming (8 2 4 2)
  C4.8 * 8 |
\ts (4 4)
\beaming (16 4 4 8)
  C4.16 * 8 
  C4.16 * 8

This feature can be used via:

Player​

player: grace beats on song start​

https://github.com/CoderLine/alphaTab/pull/2415

Grace Beats take a special role in music notation and have a fairly unique behavior regarding display and playback.

These beats do not have their own "playback time", they steal their duration from the previous or next beat, shortening it in the process.

In Guitar Pro terminology there are on-beat grace notes and before-beat grace notes stealing the duration from the next or previous beat respectively. This becomes a problem when we place a before-beat at the start of the song because there is no "previous beat" from which we can steal the duration.

This was a problem for alphaTab as the time of this beat was suddenly negative resulting in incorrect playback and cursor placement. Normally the author of the music sheet would need to rewrite the notes to have some sort of beat to steal the duration from (e.g. via pick-up/anacrusis bar or changing to an on-beat grace note). This individualization is not always possible if the input file is consumed from an external source.

We now internally handle this negative underflow and ensure the playback and display works as a user would expect it.

00:00
00:00
\subtitle "Before-Beat Grace Note"
C4 {gr bb} C4 C4 C4 C4
00:00
00:00
\subtitle "On-Beat Grace Note"
C4 {gr ob} C4 C4 C4 C4

player: smooth cursor and scrolling​

https://github.com/CoderLine/alphaTab/pull/2447

This feature adds a brand new scroll mode allowing a continuous smooth scrolling experience. The previously available modes were scrolling when the played bar changed and the related positioning condition was met (e.g. the bar was out-of-screen).

For horizontal layouts this allows a steady-cursor at a fixed position. For vertical layouts it allows a more relaxed scrolling without main jumps making it easier to follow the playback.

On top of that devs can now implement a custom scrolling logic. We extracted the current scrolling logic into dedicated components and allow devs to set their own implementations.

This way new extended scrolling systems can be built.

00:00
00:00
00:00
00:00

This feature can be used via

integration: Selection API​

https://github.com/CoderLine/alphaTab/pull/2418

This change extends the public APIs around the interactive selection of the playback range. Previously devs needed to rely on some internal behaviors to extend the alphaTab selection logic with custom parts. This made it close to impossible to cleanly implement extensions like custom selection handles.

With these changes developers can now subscribe to events during the interactive selection of a user and create new UI elements as needed (e.g. to create extended selection handles).

Additionally we ensure now to snap the selection start to the beginning of the bar if the selection starts on the first beat.

This feature can be used via:

A simple demo of the usage is also part of the development playground.

Guitar Pro extensions​

exporter: improved RSE compatibility​

https://github.com/CoderLine/alphaTab/pull/2456 https://github.com/CoderLine/alphaTab/pull/2477

Thanks @L-Sun for your contributions around this topic.

With these improvements alphaTab does now write extended RSE information into the exported Guitar Pro files. This way the playback mode in Guitar Pro can be changed to RSE resulting in proper playback.

RSE is quite a complex feature of Guitar Pro allowing advanced effect and soundbank configurations. alphaTab tries to write at least the minimum amount of information to achieve correct playback.

importer: detect bass clef (Guitar Pro 3-5)​

https://github.com/CoderLine/alphaTab/pull/2483

Older Guitar Pro files did not always contain the exact information on what clef should be shown on the staves. While some information can be contained, it was not fully working as expected and for older formats always a treble clef was shown.

We now follow the Guitar Pro 5 behavior of switching to the a bass clef based on the configured string tuning.

alphaTex Extensions​

alphaTex: bar-wise voices​

https://github.com/CoderLine/alphaTab/pull/2429

While writing various test-cases for multi-voice music sheets I realized that writing the notation voice-by-voice does not feel very natural.

By default in alphaTex, to write multiple voices, you first write the whole notation for the first voice, then you start a new voice with \voice and begin again writing the second voice at bar 1.

With this new mode, we stay in the mental model of writing notation "bar-by-bar". The \voice tag starts a new voice on the current bar until we reach the end of the bar. Thanks to this you can only add a second voice to the bars which actually have a second voice and keep the other bars simple as single voice bars.

alphaTab takes care of the internal consolidation of voices.

\subtitle "Staff-Wise Voices"
\voiceMode staffWise
\voice
  C4 | C5
\voice
  C3 | C4
\voiceMode barWise
// Bar 1
  \voice C4 
  \voice C3
|
// Bar 2
  \voice C5 
  \voice C4

This feature can be used via:

Improvements & Bugfixes​

alphaTex: Fixed diagnostics in Monaco integration​

https://github.com/CoderLine/alphaTab/pull/2413

Some last minute changes in the 1.7.0 release caused a problem that the Monaco Editor integration didn't correctly display diagnostics. Due to both pull&pull diagnostics being used, all diagnostics were listed twice.

alphaTex: Missing metadata tags in LSP completion​

https://github.com/CoderLine/alphaTab/pull/2413

Some metadata tags were not included in the list for code completions. Any staff-level metadata tags were missing in the code completions.

Now they are included as expected.

playground: Improvements in the development playground​

https://github.com/CoderLine/alphaTab/pull/2410

The development playground was improved with some more convenience features like:

  1. When importing any file into the alphaTex editor, we use the new exporter to fill the code editor with the alphaTex code for further editing.
  2. Drag and drop of files now works on the whole page
  3. alphaTab is now exposed on the window object for easy fiddling in the browser dev tools.

render: Effect bands merged into main renderers​

https://github.com/CoderLine/alphaTab/pull/2414

This is mainly a preparation for future improvements but still worth mentioning in this release. Until this release effects&annotations like vibratos, dynamics, lyrics etc. were rendered in own EffectBarRenderers.

Internally this means there were own visual "staves" for the various effects and these staves were tricky to manage.

With this change we merged these effects into the main renderers bringing following improvements:

  1. We laid the foundation to eventually align effects more efficiently with the notes contained in the bars allowing a more dense layout. Currently there can be quite a lot of white-space (especially in the horizontal layout).
  2. When the main staves (standard notation, tabs, slash notation and numbered notation) are shown/hidden we tell the next main staff to show the effect instead. Thanks to this all relevant effects are now shown for notes.
  3. Internally there is less complexity and overhead resulting in a slightly better performance.

As part of this various alignment issues have been fixed and we improved the general behavior of reserving paddings for overlaps.

alphaTex: load alphaTex from the textContent of DOM elements.​

https://github.com/CoderLine/alphaTab/pull/2417 https://github.com/CoderLine/alphaTab/commit/962b45b98b751003dcee47f5c3b557350e44ee13

alphaTab previously used the .innerHTML property of DOM elements to load the initial alphaTex code to render. Due to this HTML entities were escaped and a text like alpha & tab would result in alpha &amp; tab.

With the change to textContent this problem does not exist anymore and whitespace is still preserved for parsing mitigating expected side-effects.

rendering: improved beaming helpers​

https://github.com/CoderLine/alphaTab/pull/2427

The beaming helpers are responsible for grouping beats which can be beamed together and take care of various calculations around this.

Historically a lot of logic around the positioning of beams and related elements (tuplets, flags etc) was scattered across different places. With this improvement we have now a proper centralized handling of these aspects allowing easier adaptions and extensions for future features.

bundlers: warn about missing plugin usage​

https://github.com/CoderLine/alphaTab/pull/2436

We now detect during runtime if alphaTab was bundled via WebPack or Vite but our bundler plugins were not used. This mitigates problems when devs forget to setup the bundlers correctly.

Unless alphaTab logs are disabled in the browser, the browser console will print a warning if the plugins need to be activated.

rendering: always apply systemLabelPaddingLeft​

https://github.com/CoderLine/alphaTab/pull/2448

alphaTab only applied the padding systemLabelPaddingLeft if the tracks had a label. Now this padding is always applied ensuring a consistent display regardless of track names being set.

web: print dialog​

https://github.com/CoderLine/alphaTab/pull/2480

When we introduced the SMuFL font customization the print dialog got broken. The fonts were not registered in the print dialog and therefore no symbols were shown. This problem is now fixed. Try it out on the landing page.

audio: handle invalid BPMs​

https://github.com/CoderLine/alphaTab/pull/2484

There were some edge-cases where invalid files could lead to a hang inside alphaTab. If BPMs were set to a value <1 (e.g. 0.111), alphaTab cropped it to 0. A BPM=0 then caused a range of internal problems in the player.

alphaTab now forces the BPM to 1 inside the player to avoid any problems.

rendering: prevent wobbly beam rendering​

https://github.com/CoderLine/alphaTab/pull/2494

alphaTab tried to handle certain subpixel related problems by rounding coordinates. This had the negative effect of beams not aligning to a clean slope but they appeared "wobbly" when spanning multiple beats.

We fixed the rendering of these beams aiming for a clean display of slopes and avoiding sub-pixel related artifacts.

On standard-DPI monitors there might still be slight artifacts due to subpixel-rendering and the related anti-aliasing.

rendering: avoid flickering and wrong notation display on layout changes​

https://github.com/CoderLine/alphaTab/pull/2495

When switching between layouts, alphaTab tried to keep the existing notation displayed. This optimization was mainly in place for dynamic resizing. When switching between layouts or loading new files, this could lead to wrong elements being displayed on screen temporarily until they were re-rendered using the new information.

alphaTab now tries to detect whether the current viewport elements can be reused and clears the content if required.

Devs can supply new renderingHints in a range of API methods for scenarios where the data model is dynamically changing but generally the displayed notation stays similar.

e.g. when providing live editors a clearing of the viewport would have negative flickering effects when clearing all rendered notation.