Developers' handbook

Getting started

Compilation instructions

Finding your way around

References

Plugin development

Release notes

Events

Feel free to adjust any content or add child pages. For more information about how to add pages etc, see the administer guidelines.

Google Summer of Code

Google Summer of Code (GSoC) is a global program that offers student developers stipends to write code for various open source software projects. GSoC has worked with several open source, free software, and technology-related groups to identify and fund several projects over a three month period. Since its inception in 2005, the program has brought together over 7,500 successful student participants from 97 countries and over 7,000 mentors from over 100 countries worldwide to produce over 50 million lines of code.

Through Google Summer of Code, accepted student applicants are paired with a mentor or mentors from the participating projects, thus gaining exposure to real-world software development scenarios and the opportunity for employment in areas related to their academic pursuits. In turn, the participating projects are able to more easily identify and bring in new developers. Best of all, more source code is created and released for the use and benefit of all.

To learn more about the program, peruse our 2014 Frequently Asked Questions page. You can also subscribe to the Google Open Source Blog or the Google Summer of Code Discussion Group to keep abreast of the latest announcements.

Google Summer of Code 2014

MuseScore has been selected for Google Summer of Code 2014 and has been allocated five students to work on

You can consult the GSOC 2014 student guide.

GSoC 2014 Student Guide

What to do if you have been accepted as a student for Google Summer of Code 2014?

Create and write a blog

  • Set up a blog where you will communicate your results. It is okay to use an existing one.
  • Start posting immediately, begin with a description of your project.
  • Announce your blog, your git account, and a description of your project on musescore.org and on the developer mailing list.
  • You should write a status report every week. The first weekly report is due on Sunday, 18 May 2014 at 23:59 UTC and the subsequent reports at the same hour on a weekly interval.

Suggested sections for the status report are:

  • Key accomplishments last week
  • Key tasks that stalled
  • Tasks in the upcoming week

Weekly status reports are obligatory, if you fail to provide them, it can be a reason for not passing evaluation for Google.

Use IRC, the mailing list, and the forums

  • Subscribe to mscore-developer mailing list if you have not already done so.
  • Introduce yourself. Include the link to your blog and Git repository there
  • Describe your project in short
  • Get an IRC client and connect as often as possible to the #musescore channel on freenode.net. If you need help getting on IRC, ask on the mailing list.

All your technical questions should go through this mailing list or IRC. If you need user feedback, or have questions related to MuseScore usage, use the forum or IRC.

Ask questions in public

We're an open community so unless you have a good reason, all communication should be public.
Ask on IRC or on the mailing list unless you have a good reason to ask directly your mentor.
If you are going to use IRC, stick around until you get an answer -- your mentor (or anyone else) may be sleeping, working, or away when you first ask but may respond when they return.

Publish a Git repository

  • Publish your changes immediately in your Git repository.
  • You have to use github.com for sharing code. See Git Workflow
  • Write about location of your Git repository on mscore-developer mailing list and your blog.
  • Push every change you've done so that we can track your progress. GSoC has few deadlines, but we want to see and if possible, merge your code continuously!
  • Every commit should contain single change and the code should be working on every commit. Try to prevent huge breakages.
  • When you feel you've reached point where part of your code should be merged to main repository, just open pull request on Github or tell your mentor.

Benefit from the Community Bonding Period

  • Familiarize yourself with MuseScore's code base
  • Contact your mentor and establish a plan for the upcoming weeks

Be active

  • Be active, don't expect to be kicked and taken by the hand on every step.
  • Write weekly reports on time.
  • Submit your code early.
  • If you fail to communicate, it can lead your project being marked as failed and you won't receive any money from Google.

Don't forget documentation and tests

All new functionality you create should be documented and tested.
The documentation and tests should be done as you code, do not keep it on last moment.

After the Summer

Hopefully, your involvement with MuseScore will continue after GSoC!

Links

License

This page is licensed under GNU GPLv2 and largely inspired by PhpMyAdmin's one

Accessibility with focus on visually impaired musicians

When we talk about music score editors, one of the most notable aspects is the fact that very few of them are designed with accessibility in mind, or scarcely do they provide support for it. If they indeed meet this need, most of them are quite expensive. This leaves blind or visually impaired musicians who wish to create scores in standard notation with very few options.
This project aims to add the necessary support for assistive technologies that visually impaired musicians use in order to create a mental picture of the interface. Also, I will make all the menus, buttons and paletts accessible by keyboard, from which will benefit not only blind musicians, but also the average or "power" users who want to use MuseScore efficiently.

Andrei Tuicu
Full Proposal: https://www.dropbox.com/s/c4ndm842u201j9w/AndreiTuicu_Proposal_MuseScore...
My Blog: http://andreituicu.wordpress.com/
GitHub: https://github.com/andreituicu/MuseScore

Enhancing and testing the import of Guitar Pro files

John Pirie

http://jpirie23.wordpress.com/
https://github.com/jpirie/MuseScore

Implementation of full JACK support

JACK Audio Connection Kit is a professional sound server daemon that provides real-time, low latency connections for both audio and MIDI data between applications that implement its API.

This will be a great feature that gives an ability to connect with lots of synthesizers and Digital Audio Workstations. In general, it will be possible to route MIDI and Audio signals, to do a real-time sound effects processing and a lot of other cool things.

Maxim Grishin (igevorse)

Stay tuned:
My blog: http://igevorse.lited.net/
Github page: https://github.com/Igevorse/MuseScore

Swing Playback

MuseScore 1.3 has minimal support for Swing Playback. However, MuseScore 2.0 has no such feature. The user can only hear his score in straight. Improvements we would like to implement are:
Ability to set the swing ratio, adding swing texts specifying the swing for different parts of the score, and saving the score in swing.
This way, we would like to enable full fledged Swing Playback support for MuseScore 2.0 as part of this project. This will be a great delight for all those jazz musicians using MuseScore looking for an option to listen to their score in swing.

My blog: https://shredpub.wordpress.com
Github page: https://github.com/shredpub/MuseScore

Cheers.
Ruchit Agrawal (shredpub)

Application Template

Please read the "Writing a proposal" chapter from the GSoC student guide. The full guide is a must read if you want to apply.

Some more specific information for MuseScore.

Name

Please provide your full name.

Email / IRC / WWW

Where can we contact you? If you frequent our IRC channel (#musescore on irc.freenode.net) please let us know what your nick is. If you have a web page you'd like us to know about, please include it.

Synopsis

A short description

Benefits to MuseScore

Describe how your project will benefit MuseScore. How will it benefit musicians using MuseScore to create scores? Will it be an aid for future MuseScore development?

Deliverables

Provide a user-level summary of the final output or results of your project. How does it integrate in MuseScore and how does it cooperate with the rest of MuseScore's features?

Project Details

A more detailed description.

Project Schedule

How long will the project take? When can you begin work?
Include an estimated timeline of the project with mini-milestones
Please also note any vacation time you expect to take during the project period.

Bio

Who are you, what are you studying (and where), and what activities do you enjoy? What is your experience using MuseScore or other music notation software? What (music) code development projects you've realized? What makes you the best person to work on this project? Are you a musician? Which instrument(s)?

Google Summer of Code 2013

MuseScore has been selected for Google Summer of Code 2013 and has been allocated two students to work on

  • MIDI import improvements
  • MuseScore and Emscripten

MIDI import improvement project

=== The project goal is to improve MIDI import functionality ===

--------------------------------------------------------------------------------------
Current work

More "smooth" clef changes (for single notes, ...)

--------------------------------------------------------------------------------------
Plans

  • Availability of the original MIDI durations.
  • Quantization of slightly unaligned MIDI files.
  • - Use Simon Dixon's algorithm (C++) for automatic beat recognition.
    - Ask user to adjust, if necessary, the start and the end points of the first bar on piano roll or specify the time scale difference between MIDI events and the ideal grid.

--------------------------------------------------------------------------------------
Implemented features

Lyrics import from karaoke (.kar) files

Selectable lyric import option
Combo boxes in Lyrics column of MIDI import panel gives an opportunity to select the track to assign lyric to.
Example of karaoke file with one lyric track:

Another, manually created example shows multiple lyrics support (2 lyric tracks):

Drums import

Here is a MIDI import of drums:

Also there is an option of a drum staff splitting (thanks to chenlung for his idea):

Split without staff bracket:

Swing notation (without playback)

Here are some examples of swing detection results.

Triplet swing (2:1)

Shuffle (3:1)

Larger piece

Automatic clef selection within a staff depending on average chord pitch

Clef changes option is checked in the MIDI import panel by default.

Tuplet recognition for MIDI import

Below are some examples of automatic MIDI import.
Manual adjustments/highlights are made in a couple of cases to show that program correctly handles multiple voices.

MIDI file:
Triplets - piano roll

Result of the import:
Triplets - result of the import

Triplet

Triplet when time sig = 3/4

Triplet when time sig = 5/4 (reply to Tuplet rhythms in MIDI import)

Duplet (time sig = 6/8)

Qaudruplet (time sig = 6/8)

Triplet and other shorter notes

Mixed triplets, including triplet with rest

Septuplet

Nonuplet (time sig = 3/4), requires 1/64 quantization

Nonuplet (time sig = 4/4), requires 1/64 quantization

2 voices - triplet and regular notes

2 quintuplets (rest is inside one of them) and manually space-adjusted case

2 voices - triplet and quintuplet.
Need to manually set quantization value to 1/32

3 voices - triplet, quintuplet and septuplet simultaneously
and manually space-adjusted case + highlighted case

Larger piece example (reply to Can't open a MIDI file with triplets)

"The Oxman Returneth" by Marc Sabatella - various triplets + pickup measure

-- Recognition of first and last tuplet tied notes --

First tied note:

Last tied note:

Tied tuplets:

Track reordering in MIDI import panel

For example, left piano track goes above right track that is incorrect, so we can move right track to the top.

Pickup measure support

Duration subdivision based on metrical analysis

Notes, rests + dots and ties are created according to strong/weak bar divisions.

=> Here are some examples of automatic MIDI import:

Half note at the center of 4/4 bar

Half rest at the center of 4/4 bar

Rests and chords near beats

Half rest at the start or at the end of 3/4 bar - divided into quarter rests

Example of larger piece of music

Last quarter rest in compound meters like 6/8 - splitted into 2 8th

12/8 compound bar

Rests of mixed duration

Left/right hand separation of piano track

In addition to fixed-pitch split there is an option to take into account the average hand width of the pianist.

Example

UI panel to specify MIDI import operations

Apply operations on MIDI tracks and get the immediate result (see screenshots above).

MIDI import - for developers

Almost all MIDI import files begin with the “importmidi” prefix and are located in mscore/ directory.

Internally, MIDI import in MuseScore consists of two main stages:

  • track information extraction from the MIDI file to fill the track list in the MIDI import panel
  • import of “music” MIDI events with the default values of applied operations

All of the import is controlled by values of the MIDI import operations (default or user-defined). Those operations are stored in the MidiImportOperations class and may be different for each track. This class also contains MidiData class which is responsible for the storage of contents of the MIDI file (necessary because the user can switch between multiple open MIDI files). The object of MidiImportOperations class is stored in MuseScore Preferences class, which can be found in mscore/preferences.h.

The opening of a MIDI file is followed by a range of internal program actions, the main ones are:

  • musescore.cpp calls the MIDI import panel’s function setMidiFile that is located in importmidi_panel.cpp
  • the MIDI import panel invokes the meta track info extraction function (extractMidiTracksMeta) in importmidi.cpp
  • the importMidi function in importmidi.cpp is called, which performs all necessary calculations and adds the music information from the MIDI file to the new score

If the user changes the operations and clicks the Apply button, the doMidiImport function (from importmidi_panel.cpp) obtains the values of operations from the GUI model and saves it in the preferences.midiImportOperations object. After, the usual importMidi function is called. Immediately after the import function performs its job, the preferences.midiImportOperations object is cleared.

The MIDI “music” import stage reads the MIDI file information previously stored in preferences.midiImportOperations.midiData object and calls convertMidi function from the importmidi.cpp file. After, all operations and algorithmic manipulations are applied to the MIDI file content:

  • list of track objects is created; tracks without note events are omitted
  • each note is stored in object of MidiChord class
  • all notes with very close “on time” events are combined into chords, also in class
  • notes too short are cleaned up
  • overlapping notes of equal pitch are corrected to rid of their intersection (removeOverlappingNotes function, importmidi.cpp)
  • a tuplet search is performed (importmidi_tuplet.cpp); multiple voices are also taken into account
  • after that - quantization of all chords (importmidi_quant.cpp); tuplets and non-tuplet notes are quantized by different grids
  • removeOverlappingNotes is called once again
  • if the user decides - the track is subdivided into left/right hand parts (a purpose mainly for piano tracks) - importmidi_lrhand.cpp
  • chords with notes of different length are separated into different chords with equal notes (splitUnequalChords function in importmidi.cpp)
  • import of drums (importmidi_drum.cpp)
  • instruments are created
  • measures (bars) are created, so now it’s possible to find a bar by tick
  • chord durations are converted into music notation; metrical analysis is performed here to find preferable duration subdivision in bar according to strong/weak bar fractions (see importmidi_meter.cpp)
    after that track meta is set
  • tuplets are added to the score, according to recognized tuplet events that are stored in MTrack::tuplets multimap
  • key signatures are created
  • if the user chooses - the program tries to detect swing: to replace triplet [4th + 8th] by 2 straight 8ths (for usual swing, 2:1) or dotted 8th + 16th by 2 straight 8ths as well (for shuffle, 3:1); the search of patterns and note replacement is performed on score chord/rest segments; code for swing detection is in importmidi_swing.cpp
  • clefs are created, they are of two types: at the beginning of staff (mandatory clefs) and, if the user wishes, clefs may change (added) within a staff depending on average chord pitch to make the score more “smooth”. Tied notes are not supposed to be separated by the clef insertion - algorithm tries to check it (code is in importmidi_clef.cpp)
  • time signatures are created
  • lyrics are imported, if any - importmidi_lyrics.cpp (lyric can be a title, composer or text next to notes - like song words)

The score is then rendered by the MuseScore graphics engine.

***

Currently to add a new operation one should add some pieces of code to several places (maybe it will be possible to bring all this pieces into one place in the future):

  • register the new type of operation in impotmidi_operation.h - MidiOperation::Type
    add operation variable into the TrackOperations struct in importmidi_operations.h and set the default value in C++11 manner
  • insert a new node in importmidi_opmodel.cpp that will be shown in the MIDI import panel; connect to the controller if necessary; controller hides/shows the nodes according to some defined rules (for example, “Allow clef change…” is a hidden node for drum tracks)
  • add operation to the setNodeOperations function in importmidi_opmodel.cpp
  • add operation to the setTrackOperation function in importmidi_trmodel.cpp
  • add operation to the trackOperations function in the same file

The operation then becomes available for the MIDI import algorithms.

***

MIDI import tests are located in mtest/importmidi/tst_importmidi.cpp

To test functions that have only definition in cpp file, the auxiliary file mtest/importmidi/inner_func_decl.h header is used where the headers of such tested functions should be put.

MuseScore and Emscripten

libmscore ported to the browser using Emscripten

Google-Melange public project page: project page
Original Proposal: proposal
Git Repos:

  • libmscore port: Repo
  • EmbindGenerator script: Repo
  • Sha of last MuseScore commit, before branching: f9f8462d96

Documentation (how to set up libmscore with emscripten): here
Progress Log (archive): log

Google Summer of Code wrap-up/summary

You can find documentation on how to set-up your environment to begin using libmscore in Javascript here.

All of the work of getting emscripten to compile the libmscore code itself is completed and documented, even if all of that code isn't fully usable yet. This means that others should be able to reproduce the process of compiling libmscore to Javascript. If anyone attempts this process, I welcome all feedback so that I might improve it.

It is important to note that porting future versions of libmscore to emscripten (that is, versions of libmscore which now use qt5), will require additional work of first porting qt5 to Javascript. As of the time of writing, I'm not aware of any initiatives looking to complete this task. Qt5 was only fully "released" just over a year ago, and MuseScore itself did not make the complete switch over until just the past summer, so I think with time this task will be realized. From there, the process of porting over libmscore would follow a process very similar to the one I outlined for versions of libmscore using Qt4.8.

While I did not complete all of the goals outlined in my original proposal, libmscore is at a point where it is possible to load a simple score into the browser and verify some of the metadata. From here, it's a matter of debugging the remaining issues and exposing more libmscore functionality to Javascript. My hope is that outside of GSoC I can continue working on this project so that I can accomplish the goals outlined in the original proposal. I feel I am very close to those goals. I hope that someone more experienced with Qt5 will take up the task of porting Qt5 to emscripten, or perhaps maybe I could take up the task myself down the road. With Qt5 ported to emscripten, I still see many benefits of getting newer versions of libmscore to work in the browser. I would like to see that become a reality.

Progress Log

This was removed from the main page. It basically contains a log of the progress I made on the project over the summer.

Progress Log

Current Work (last updated 23 September 2013)

  • Continue debugging errors related to fonts.

Next Steps

  • Verify that the score has loaded correctly
  • Get a score to paint on the screen
  • Clean up the libmscore changes

Previous Work

  • (7 September 2013) Verified and loaded a score, but loading more complicated scores with text (as well as rendering) has presented issues with font loading, therefore I've been looking into that problem. It seems that QPF format fonts might be easier to load, but getting the makeqpf utility which creates those files proved complicated, as QPF doesn't seem very current with Qt. Talking to the creator of emscriptenqt, it seems the true-type font loading issue might be a problem within emscriptenqt itself, so I've been exploring the source trying to track it down. In the meantime I've created my own branch of emscriptenqt to track changes.
  • (23 August 2013) Continuing work on loading the score. Initialization seems to be working, but I had to comment out some methods to get that to work, which appear to be causing problems with the loading of a score. I now either must stub out all methods related to some of the graphical initialization which was skipped, or re-visit some of the initialization code. For the time being, stubbing out the methods seems to be the better option until I can get a score fully loaded and verified.
  • (15 August 2013) Currently working on loading a score and verifying the score loaded correctly (by printing out some meta info). Right now, I have exposed some methods to javascript which allow me to load the score, and I'm sorting out some bugs related to the transition from a traditional desktop app to a javascript one (embedded files, initialization, etc.).
  • I'm also working on creating a better testing process. I had looked into using PhantomJS, but it appears they're using an older version of webkit which doesn't have some of the javascript features required by emscripten. For now I'll just be using javascript files and the javascript console.
  • (updated 30 July 2013) Working on getting just one class (Score) to have some methods exposed so that I can load a score into the browser and then hopefully render it. So far I'm able to instantiate an instance of score in the browser, but I'm getting some weird thing about unbound types. Been getting help on the emscripten irc to sort through these errors. Hopefully this won't be too much of a set-back.
    • Relevant paste: paste
    • update: I've abandoned using embind for now, and I'm just using C wrappers and "EXPORTED_FUNCTIONS." This seems to be a lot simpler to expose more methods, although it's a little less flexible and not as streamlined.
  • UPDATE (24 July 2013): I've created a repository for the embindgenerator script here: repo
  • UPDATE (23 July 2013): Using the doxygen XML file I'm able to extract code structure from a collection of source files. I then feed that file into a node script I'm developing which parses the file (using xmldom, a node module) and traverses the document, generating a cpp embind file as it goes along. This script is not yet complete, but I'm making steady progress. The script is already able to identify structures which need to embind declarations generated for them.
    • Sample generated file: |sample
    • Here is another sample, this one is the "Page" class from libmscore, still have a few things to tweak: Page_EMBIND
  • UPDATE (19 July 2013) : Continuing experiments with embind lead mixed results. Succesfully got some example projects working with the "EXPORTED_FUNCTIONS" method, and when calling embind on a single file, but when trying to use embind on a project consisting of more than one file I'm having lots of problems. I successfully generate the bitcode, but it seems that these methods aren't getting exposed in javascript. I'm going to do some more experimenting and debugging as well as trying to find more documentation on embind and asking for help in the irc. I've also been looking into automated generation of the embind bindings. It seems someone created a tool for visual studio which does it (can be found here), but using visual studio is far from ideal. Talking to the creator, it seems that he got doxygen to generate an xml file containing the layout of the code, and then using that generated code structure created the embindings. I think creating a Node.js tool which generates these embindings would be something worthwhile. Once I get the bindings created manually working, I'm going to look into that.
    • UPDATE (20 July 2013): After quite some time of checking and re-checking my work, turns out I was using "--embind" as the compiler flag, instead of "--bind" which is the correct flag. Embind seems to be working as expected now and I plan to move on to creating a tool which will automatically generate embind files.
  • UPDATE (9 July 2013) : First taste of success -- generated bitcode out of the libmscore source using emscripten. Unfortunately, getting libmscore's c++ classes and functions exposed to Javascript may prove a bit tricky. It seems there are several routes to take. I'm going to do some research and possibly a little experimentation with these methods before committing to one.
    • Emscripten, interacting with code: link
    • Embind, a tool which exposes c++ classes: link

    Hopefully I can find a way to automate as much of this process as possible to make future patches simpler.

  • UPDATE (6 July 2013): Figured out how to get emscripten-qt to compile with support for SVG and QDeclarative stuff. After some experimentation, solidified that LLVM 3.4 will not work with emscripten, at least not without more patching to emscripten itself, which is likely outside the scope of this project. That left me with either rewrite parts of libmscore to use different data structures or modify some header files that used the atomic calls. Since everything in emscripten doesn't use multiple-threads, I can just modify some of the headers to do their literal sequential operations rather than use the (unsupported) atomic calls. This seems like the most likely solution right now. After I complete this, if everything seems to be working, I'm going to go back and clean up some of the libmscore changes I made which I don't think are necessary anymore.
  • Modify the header to stub out the atomic methods doing their simple sequential counterparts instead.
  • Create a qmake build for libmscore that uses emscripten-qt's qmake.
    • UPDATE (28 June 2013): Have been fighting with basically getting a square peg to fit in a round hole. Encountered a bug in llvm 3.2 in which some library functions for c++11 weren't yet implemented. These bugs were fixed in 3.4, but emscripten only supports llvm 3.2. A branch of emscripten supports llvm 3.3, which I've been trying to make work for llvm 3.4. Emscripten-qt's demos failed, but I decided to go ahead and try to build libmscore with this configuration anyway, but I've been encountering lots of inter-dependencies between libmscore and the rest of MuseScore. I've mostly been solving these by stubbing out methods and commenting out lines, tracking any changes I make in a log. If this configuration of emscripten and llvm doesn't work, I have talked with lasconic about several alternatives I might pursue.
    • Pursue alternative configurations, listed below.
      • Try to isolate the bugfix in 3.4, and fork llvm
      • Rewrite the parts of libmscore which are victim to the bug in llvm 3.2. It seems like it might be Map or atomic operations causing the problems.
    • UPDATE (21 June 2013): I've created a qmake.pro file, as well as some other files which are normally intermediately generated during a build (all.h and config.h), which seem to be working well. Now I'm just plowing through the innevitable rampant compiler-errors. I'm keeping track of all the changes I make from a "vanilla" libmscore build so that I can walk through all my steps as well as reproduce it. My goal is to get everything to compile with emscripten, and then once it's working go back and optimize.
    • For reference I will look at https://github.com/wschweer/mscoreserver which also uses qmake to build libmscore.
  • UPDATE (18 June 2013): emscripten-qt configured and working. Wrote up a short summary of the steps to get emscripten-qt running attached as a child page.
  • UPDATE (17 June 2013): Continued attempts with emscripten-qt show light on a possible bug in emscripten, looking into work-arounds. Also began work on what will need changed in libmscore's build process (CMakeLists.txt and such) to use the qmake from emscripten-qt as well as emcc and emscripten's build tools. Should more or less still be on schedule with the original proposal timeline as long as I can solve these problems by the end of the week.
  • UPDATE (6 June 2013): having some difficulties getting emscripten-qt examples to run. I've been exchanging correspondence with Simon St James (creator of emscripten-qt) to sort through them, who has been extremely helpful. Making progress.
  • Setting up my work environment, git, etc..
  • Looking through libmscore code and reading relevant documentation (especially coding rules).
  • Reading Emscripten documentation
  • Learning the details of the libmscore build process

Setting up LLVM/clang, emscripten, and emscripten-qt

Introduction

From llvm.org, "the LLVM Project is a collection of modular and reusable compiler and toolchain technologies." It is used for the optimization of programs written in arbitrary programming languages. Clang is a C/C++ front-end for LLVM. Emscripten uses these technologies to convert C++ code into Javascript. Emscripten-qt adds support for Qt in Emscripten.

This guide will go through the process of setting up these tools, designed for a Linux environment, although many of the links have instructions for other operating systems as well.

Versions

Versions of software used:

  • Linux:
    • linuxmint-13-xfce-64
  • llvm:
    • LLVM (http://llvm.org/):
      LLVM version 3.2svn
      Optimized build with assertions.
      Built Apr 15 2013 (11:06:21).
      Default target: x86_64-unknown-linux-gnu
      Host CPU: corei7
  • CLANG:
    • clang version 3.2 (tags/RELEASE_32/final)
      Target: x86_64-unknown-linux-gnu
      Thread model: posix
  • emcc (emscripten):
    • emcc (Emscripten GCC-like replacement) 1.4.9 (commit 0ad87244178badf26cd5c8e0ed88116e87026472)
  • node:
    • v0.10.0
  • qmake (emscripten-qt) :
    • QMake version 2.01a
      Using Qt version 4.8.4

LLVM and Clang

To get LLVM set-up, simply follow the steps provided on LLVM: Getting Started. Be sure that you meet all of the requirements listed on the requirements section, and then follow the steps outlined on getting started a summary.

After llvm/clang are finished compiling, add the directory where the binaries are to your path. Should be something like "/home/user/somewhereInHome/llvm/Release+Asserts/bin" then try these examples to make sure everything is working:
(the parts in [] are notes, don't type them)

clang --help
clang file.c -fsyntax-only             [check for correctness]
clang file.c -S -emit-llvm -o -        [print out unoptimized llvm code]
clang file.c -S -emit-llvm -o - -O3
clang file.c -S -O3 -o -               [output native machine code]

if everything ran successfully, then clang and LLVM are configured correctly and you can move on to the next step.

Emscripten and Emscripten-qt

For emscripten and emscripten-qt, just follow the instructions on the emscripten-qt wiki the section "how do I use it." The instructions are fairly detailed, and I will summarize them here:

Create a directory (probably somewhere in your home directory) for emscripten and emscripten-qt. For the sake of this guide, that directory will be referred to as "/home/user/emscriptenqt/", make sure to replace all instances of that directory with what your's actually is.
Enter the following commands, replacing /home/user/emscriptenqt

mkdir build-emscripten-qt
cd build-emscripten-qt
export EMSCRIPTEN_ROOT_PATH=/home/user/emscriptenqt/emscripten/
../emscripten-qt/configure -xplatform qws/emscripten-clang  -embedded emscripten -static -opensource -debug  -no-qt3support -no-opengl -no-openssl   -system-zlib -no-gif -qt-zlib -qt-libpng -no-libmng -no-libtiff -qt-libjpeg -no-accessibility -dbus -script -no-fpu -no-mmx -no-3dnow -no-sse -no-sse2 -no-sse3 -no-ssse3 -no-sse4.1 -no-sse4.2 -no-icu -no-rpath  -confirm-license -no-webkit -no-phonon -no-freetype -nomake demos -nomake examples -little-endian -no-feature-socket  -no-feature-codecs -no-feature-textcodecplugin -no-feature-systemlocale  -no-feature-qws_multiprocess -no-feature-sound    -no-feature-printpreviewwidget  -no-feature-printpreviewdialog  -no-feature-systemsemaphore -no-feature-sharedmemory -no-feature-localeventloop -feature-qws_clientblit -feature-qws_cursor  -depths 32 -make tools  --prefix=$(pwd)/install
make sub-tools-bootstrap && make install_qmake sub-moc-install_subtargets sub-uic-install_subtargets sub-rcc-install_subtargets && make  sub-corelib-install_subtargets sub-gui-install_subtargets install_mkspecs

Now you should have emscripten and emscripten-qt. You may wish to add /home/user/emscriptenqt/emscripten to your PATH, but it is not necessary. Next, we will run an example Qt app to make sure that everything is working correctly.

cd ..
mkdir qtdemos
cd qtdemos
export PATH=/home/user/emscriptenqt/build-emscripten-qt/install/bin/:$PATH
export QMAKESPEC=/home/user/emscriptenqt/build-emscripten-qt/install/mkspecs/qws/emscripten-clang
cp -R ../emscripten-qt/demos/chip .
cd chip
patch main.cpp < ../../emscripten-qt/emscripten-stuff/chip-emscripten-qt-patch.patch 
cd ..
mkdir build
cd build
qmake ../chip/chip.pro
make
mkdir -p qt-fonts && cp ../../build-emscripten-qt/install/lib/fonts/helvetica_*.qpf ../../build-emscripten-qt/install/lib/fonts/fixed_*.qpf qt-fonts/
cp ../../build-emscripten-qt/install/lib/QtGui.a QtGui.so
cp ../../build-emscripten-qt/install/lib/QtCore.a QtCore.so
../../emscripten/emcc \
  chip.bc \
  QtGui.so QtCore.so \
  -O2 \
  --closure 0 \
  --jcache \
  --pre-js ../../emscripten-qt/emscripten-stuff/pre-qt.js \
  --js-library ../../emscripten-qt/emscripten-stuff/pre-qt-library.js \
  --embed-file qt-fonts \
  -s EXPORTED_FUNCTIONS="['_main', '_EMSCRIPTENQT_resetTimerCallback', '_EMSCRIPTENQT_timerCallback', '_EMSCRIPTENQT_timerCallback_springboard', '_EMSCRIPTEN_canvas_width_pixels', '_EMSCRIPTEN_canvas_height_pixels', '_EMSCRIPTENQT_mouseCanvasPosChanged', '_EMSCRIPTENQT_mouseCanvasButtonChanged']" \
  -s TOTAL_MEMORY=67108864 \
  -s INLINING_LIMIT=50 \
  -o chip.html 

The emscripten-qt wiki goes into more detail about what all of the parameters and commands mean.

If all completes as it should, you should now have a chip.html file in that directory. Open it with a supported browser, and the chip's demo page will load. If so, then emscripten-qt is working as it should, and you're finished!

NOTE: you might notice that the generated canvas isn't large enough to display all of the chip's demo. Apparently emscripten-qt does not yet support dynamically resizing of the canvas, and the canvas must be set manually to the correct size. On about line 23 of the generated html file, you should find:

<canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()"></canvas>

change it to something like:

<canvas width="800px" height="600px" class="emscripten" id="canvas" oncontextmenu="event.preventDefault()"></canvas>

Using emscripten to port libmscore to Javascript

Setting up Libmscore emscripten development[a]

Getting Started

First, follow all of the steps outlined here for how to set up LLVM/clang, emscripten, and emscriptenqt

Next, you can either clone a version of libmscore already set up for emscripten here or you can try to clone a pre-qt5 version of libmscore and follow the notes in appendix A of the necessary changes to use emscripten/qt.

As of the time of writing, emscriptenqt will not work with the latest version of LLVM/clang, however, using the compatible version will generate build errors because of unsupported atomic calls. Since everything done in emscripten is basically synchronous, this is not really an issue, and these atomic methods can be stubbed out. I have already created a file called “atomic_fixed” Move and rename this file (remove the “_fixed” suffix) to “emscripten/system/include/libcxx/atomic” where “emscripten” is the folder which contains your emscripten directory.

Once you have the libmscore code and emscripten and emscriptenqt set up, open up the “build.sh” file (or obtain one here), and edit the “EMSCRIPTEN_FOLDER” to point to your folder which contains the emscripten and emscripten-qt folders.

When the build.sh file is set up correctly, you can simply run “./build.sh” and that will generate a “libmscore.js” file which contains libmscore code converted to javascript. Make sure that you have the valid EXPORTs from the emscripten setup process:

export PATH=/path/to/emscriptenqt/build-emscripten-qt/install/bin/:$PATH
export QMAKESPEC=/path/to/emscriptenqt/build-emscripten-qt/install/mkspecs/qws/emscripten-clang
export PATH=/path/to/emscriptenqt/emscripten/:$PATH

You will need these exports everytime before you build. Replace “path/to/emscriptenqt” with the path to your emscriptenqt folder.I recommend creating a simple shell script containing those lines, which you can simply run before the build.

Exposing Libmscore’s C++ methods to Javascript

Once libmscore.js has been generated successfully, there are still more steps to expose libmscore methods to Javascript. Any desired methods must be exported during the compile step (part of build.sh), and they must be added to Module in Javascript. Also, it’s usually useful to wrap C++ methods in an extern “C” {} section and stick to C-style calls, as these are easier to export.

For my purposes, I found it easiest to put all my wrapped functions into “embinds/classScore.cpp” : classScore.cpp. There you can see how I wrap C++ class methods and such, and the basic naming convention that I followed. This was mostly to prevent conflicts with existing libmscore code and for ease of use of exporting to javascript.

Next, add this method to the “-s EXPORTED_FUNCTIONS” array in the build.sh file: this line. Note, you do have to add a “_” before the function name when listing it in this array, even though that method doesn’t have a “_” in the source.

Finally, you call “Module.cwrap” from Javascript, before calling your method. This is explained in better detail here. Following my examples in test.html should be fairly straightforward: test.html. I put all my cwraps into one large “Libmscore” object.

It’s important to note that “Module.cwrap”, the emscripten functionality that allows calling these methods, only understands basic types: number, boolean, and String (for char*). Any pointers to objects are just treated as a number as an index to the emscripten’s heap object. So it’s perfectly fine to pass that number in and out of wrapped methods, but you can’t expect to do anything with that pointer in regular javascript, because to JS it will just be a number. With Strings, emscripten works some magic that copies a passed in string to its internal memory structure, and then passes that created pointer to the C++ method.

After you have successfully exported the method and cwrap’d it, you can call from normal javascript, like in test.html.

Appendix A: Modifying libmscore for emscripten

Foreward: this is a collection of my notes detailing the steps I took to convert a normal clone of MuseScore into the codebase I used for compiling with emscripten/qt. I don’t imagine these exact steps will work with any other version of MuseScore except for the specific one I used, but the process should be similar. It is therefore my hope that these notes may be useful for any interested party to replicate the process for a different version of MuseScore.

First I cloned MuseScore from this sha. I then copied the entirety of the “libmscore” folder out of that directory and into a different one. I then created a new repository in that directory. This allowed me to keep most of what I was doing separate from the rest of MuseScore, while pulling in only the pieces I needed.

I created a libmscore.pro qmake project file more or less following a template similar to mscoreserver's project file. I removed things which were not necessary for the emscripten port. The current .pro file I’m using (at the time of writing) looks like this. Of particular interest will be the cxxflags, sources and includes, the “QT += svg declarative”, and the precompiled header. I added “-std=gnu++11” and “-stdlib=libc++” lines, and removed “-fno-rtti.”

I also copied over the “all.h” precompiled header from the MuseScore repo into the new repo. This file could probably be generated during the build process, but for my purposes I did not pursue this route. There were some files I needed to remove from “all.h”, these included:
QWebView, QWebFrame, QtXml, QAbstractMessageHandler, QXmlSchema, QXmlSchemaValidator, QXmlStreamReader, QNetworkAccessManager, QNetworkReply, QNetworkCookieJar, QHostAddress, QUdpSocket, QHttpPart, QHttpMultiPart, QDeclarativeEngine, QDeclarativeComponent, QDeclarativeItem, and QDeclarativeView. “all.h” should end up looking something like this.

I copied over “config.h.in” from the MuseScore repo into the new repo, and renamed it “config.h” I had to mess around with some of the defines, such as USE_ALSA and other audio flags, resulting in this.

I had to add some missing includes to all.h ( and ).

Lots of methods which had to deal with midi events and synthesizer stuff had to be stubbed and commented out. Mostly inside of “instrument.h”, “undo.h”, “undo.cpp”, “instrtemplate.h”, “instrtemplate.cpp”, “instrument_p.h”, “instrument.cpp”, “keyfinder.cpp”, “layout.cpp”, “pitchspelling.cpp”, and “rendermidi.cpp”

Edited the synthesizer source files to remove and reference to “effects/effect.h” stuff, then removed that include from those files.

I had to rename “QZipReader”, “QZipWriter”, and “CentralFileHeader” because of conflicts with emscriptenqt classes. I simply added an “M” onto the end of all these classes.

I commented out the chord list loading stuff in “style.cpp”

I commented out a lot of the fonts in mscore.cpp so that I could test loading one font at a time to see which were giving issues.

After these steps I was able to get a very basic score file to load (this score) and was able to verify some of the meta tags associated with it.

Ideas 2010

Your proposal

We strongly believe that the best proposal for you is the one you'll do. If you have any suggestion pass by the IRC channel #musescore or contact us on the developer mailing list

Add fretboard & tabstaff support in MuseScore

Difficulty: Hard
Skills: C++ / Qt graphics, guitar theory
Possible mentor: Werner
Status: Fretboards partially implemented in development builds for MuseScore. See http://musescore.org/en/node/5262#comment-17026 Implemented

Extend the Qt Script based plugin framework

The plugin framework is still very young but there are already some plugins. Plugin developers have a lot of ideas to bring more features to MuseScore.
Difficulty: Moderate
Skills: C++ / Qt
Possible mentor: lasconic
Status: Implemented

Implement a plugin manager in MuseScore

See plugin manager

  • Define a plugin package and write documentation for plugin developers
  • Create interface in MuseScore to list, install, uninstall plugins
  • Need to deal with security
  • Bonus: Update and compatibity management

Difficulty: Moderate to Hard
Skills: C++ / Qt
Possible mentor: lasconic

Offer self installable language packs on musescore.org

MuseScore software is translated in more than 20 languages thanks to the drupal based site at http://translate.musescore.org The languague files are provided as qm file on this website but a lot of users it would be more convenient to download an auto installable language file.
Difficulty: Moderate
Skills: Depending on your proposition C++ / CMake / NSIS
Possible mentor: lasconic

Automated upgrade of MuseScore

In MuseScore 0.9.6, a automated check for upgrade has been added. For next version, users would be able to check for update, download the upgrade package, install it and restart MuseScore
Difficulty: Moderate to hard
Skills: C++
Possible mentor: thomas_
Status: Implemented

Setup automated testing

MuseScore being an interactive software, it needs UI testing to improve his stability. MuseScore community has setup a wiki page to gather information about this topic. Your role will be to choose the right tool, write testing scenarii etc...
Difficulty: Moderate to hard
Skills: Depending on your proposal
Possible mentor: david

Improve MIDI file import

Improvements in this area could include:

  • Triplet handling
  • Voice and staff separation

Difficulty: Hard
Skills: AI, C++, Music
Possible mentor: werner

Enhance the Audio Widget Library for better user experience

The Audio Widget Library contains the controls for Volume, Mixer etc... Users will benefit a more usable and good looking set of controls.
Difficulty: Easy
Skills: C++, Qt, ergonomy
Possible mentor: lasconic

Play progressive dynamic and tempo changes

Currently MuseScore plays dynamic and tempo changes but can't deal with ritardando or crescendo
Difficulty: Easy to Hard depending on the proposal
Skills: C++, Qt
Possible mentor: lasconic
Status: Implemented

Ideas 2011

Your proposal

We strongly believe that the best proposal for you is the one you'll do. If you have any suggestion pass by the IRC channel #musescore or contact us on the developer mailing list

Implement a plugin manager in MuseScore

See plugin manager

  • Define a plugin package and write documentation for plugin developers
  • Create interface in MuseScore to list, install, uninstall plugins
  • Need to deal with security
  • Bonus: Update and compatibity management

Difficulty: Moderate to Hard
Skills: C++ / Qt
Possible mentor: lasconic

Offer self installable language packs on musescore.org

MuseScore software is translated in more than 20 languages thanks to the drupal based site at http://translate.musescore.org The languague files are provided as qm file on this website, but fur a lot of users it would be more convenient to download an auto installable language file.
Difficulty: Moderate
Skills: Depending on your proposition C++ / CMake / NSIS
Possible mentor: lasconic

Setup automated testing

MuseScore being an interactive software, it needs UI testing to improve his stability. MuseScore community has setup a wiki page to gather information about this topic. Your role will be to choose the right tool, write testing scenarii etc...
Difficulty: Moderate to hard
Skills: Depending on your proposal
Possible mentor: david

Improve MIDI file import

Improvements in this area could include:

  • Triplet handling
  • Voice and staff separation

Difficulty: Hard
Skills: AI, C++, Music
Possible mentor: werner
Additional information: Current state of MIDI import by Kevin Hylee.

Enhance the Audio Widget Library for better user experience

The Audio Widget Library contains the controls for Volume, Mixer etc... Users will benefit a more usable and good looking set of controls.
Difficulty: Easy
Skills: C++, Qt, ergonomy
Possible mentor: lasconic

Ideas 2012

Your proposal

We strongly believe that the best proposal for you is the one you'll do. If you have any suggestions, come on IRC channel #musescore, or contact us on the developer mailing list

Instrument Editor

  • read instrument description files (done)
  • build a GUI to display and edit all instruments
  • show list of instruments
  • display all attributes of currently-selected instrument
  • make all attributes editable
  • create new instrument, use currently-selected instrument as a starting point
  • remove instrument
  • change currently-selected instrument
  • save instrument descriptions
  • save as

Difficulty: Easy to Medium
Skills: C++ / Qt. No detailed knowledge of MuseScore internals is required, except for the InstrumentTemplate class usage. The code is mostly independent of MuseScore core development.
Estimated LOC required is 4000.
Possible mentor: lasconic

Beam mode editor

A UI to edit the rules of beam groups and a way to assign the rules to measure, staff etc... similar to time signature (measure based, different by staff)

Difficulty: Moderate
Skills: C++ / Qt. A bit of knowledge of MuseScore internals.
Possible mentor: lasconic

Symbol Editor

Create an editor for MuseScore specific graphical symbols which are in SVG format.
A specialized (simplified) variant of this project is to create an editor for note heads.

Difficulty: Moderate to Hard
Skills: C++ / Qt. Requires some knowledge of MuseScore internals.

Integrate Breakpad

What is BreakPad
"Breakpad is a library and tool suite that allows you to distribute an application to users with compiler-provided debugging information removed, record crashes in compact "minidump" files, send them back to your server, and produce C and C++ stack traces from these minidumps. Breakpad can also write minidumps on request for programs that have not crashed. Breakpad is currently used by Google Chrome, Firefox, Google Picasa, Camino, Google Earth, and other projects."

Difficulty: Moderate to Hard
Skills: C++ / Qt
Possible mentor: lasconic

Ideas 2013

Your proposal

We strongly believe that the best proposal for you is the one you'll do. If you have any suggestions, come on IRC channel #musescore, or contact us on the developer mailing list. To officially apply your summer project idea, follow this link.

Also check ideas from previous years: http://musescore.org/en/developers-handbook/google-summer-code

MuseScore NaCl

Port a part of MuseScore to Native Client (NaCl). There are already some experiment with Qt and NaCl. It would mean the ability to display, play, transpose sheet music in the browser without any plugin.

Difficulty: Hard
Skills: C++/Qt/QML/NaCl/Chromium
Possible mentor: lasconic
Student: Apply here

MuseScore EmScripten

Port a part of MuseScore to Javascript using a language translation tool such as Emscripten. The goal could be to display and transpose a MSCZ file in the browser. Emscripten-Qt is a good start.

Difficulty: Hard
Skills: C++/Qt/Emscripten/LLVM/Javascript
Possible mentor: lasconic
Student: Apply here

MuseScore resources repository

MuseScore is highly customizable. Users can change soundfonts, add plugins, define workspaces, templates, palettes, languages etc... What if there would be an easy way to share all these resources in the cloud and a one click way to install/uninstall them in MuseScore.
Some resources to check OCS, Attica client library, KDE Bodega...

Difficulty: Medium
Skills: PHP/C++/Qt
Possible mentor: lasconic
Student: Apply here

Jianpu notation support in MuseScore

Jianpu notation/Numbered musical notation is widely used in China. A large amount of Chinese music is recorded in Jianpu and most Chinese people are more familiar with Jianpu than standard staff scores. But there are relatively limited software for editing Jianpu and they have obvious disadvantages. In sum, there's a need for high quality Jianpu notation software. For more information: Here.

Difficulty: Hard
Skills: C++/Qt
Student: Eli Yang
Possible mentor: lasconic, Rui Fan (aka Vanferry)

Improve MIDI import

MuseScore currently imports MIDI files quite badly. There are many areas in which MIDI import could be improved and most of them require smart algorithms. This project would target several key problems.

  • Tuplet import: Currently, MuseScore considers only binary note values.
  • Dot vs Tie: Currently, MuseScore always uses ties and never dots.
  • Drums import
  • Tempo changes
  • Swing import: if a MIDI file is played with swing, MuseScore should be able to recognize it and notate it as straight notes, but still play swing.
  • Voice separation: MuseScore puts everything under voice 1 currently.
  • Treble/Bass clefs discrimination for piano: MuseScore currently uses a fixed point to separate the treble and bass clef. A smarter algorithm could be found.

shot_130418_125502.png
Difficulty: Medium
Skills: C++/Qt, AI
Possible mentor: werner

Fichier attachéTaille
shot_130418_125502.png19.34 Ko

Ideas 2014

Your proposal

We strongly believe that the best proposal for you is the one you'll do. If you have any suggestions, come on IRC channel #musescore on freenode.net, or contact us on the developer mailing list.

Also check ideas from previous years: http://musescore.org/en/developers-handbook/google-summer-code

Accessibility for Visually Impaired Musicians

Blind musicians wishing to create scores in standard notation currently have very few options, since most notation software is not designed with accessibility in mind. It can also be difficult for blind or visually impaired musicians to obtain scores in Braille or other "accessible" formats (large print editions, electronic formats that read scores aloud, etc). MuseScore could be a revolutionary tool in the community of blind musicians if it were enhanced to address these concerns.

Some of the areas that need work:

  • Making all menus, dialogs, and windows keyboard and screen-reader friendly
  • Adding full keyboard control for score navigation, including the ability to traverse all score elements rather than just notes and rests
  • Enhance status line display or add new window, with screenreader support, to provide meaningful feedback during navigation
  • Making all score editing operations performable via keyboard
  • Improving automatic layout facilities to reduce need for a sighted user to identify places where manual adjustments are needed
  • Extending MusicXML export as necessary to better support automated MusicXML-Braille converters
  • Plugins or other automation for export to Braille or other accessible formats (via MusicXML using existing tools)

Some of these are relatively easy, others much more difficult. The whole job is very big, but implementing even portions of this could change the lives of many blind musicians.

For more on this topic, see the Accessible Music Notation Project site, and the MuseScore Accessibility document in particular.

Difficulty: Easy to Hard
Skills: C++/Qt
Possible mentor: Marc Sabatella

Better support of Guitar Pro import

Guitar Pro is a very popular software to create tablature. There are a lot of Guitar Pro files on the web. MuseScore 2.0 will be able to create tablature and has minimal support for Guitar Pro 3, 4 and 5 files. There is no support for Guitar Pro 6 format.
Importing these file formats will make available hundreds of thousands arrangements to MuseScore users. They would be able to play and edit them. No other free and open source tool support the 4 formats.

Some of the areas that need work:

Difficulty: Easy to Medium
Skills: C++/Qt
Possible mentor: Nicolas Froment (@lasconic) / Maurizio A. Gavioli (@Miwarre)

Virtual singer

Several users requested a virtual singer in MuseScore. This feature would make MuseScore sing the lyrics in a score. It's useful for singers in choir who likes to rehearse with actual synthesized lyrics.

There are several specialized (open source) software projects and libraries which do "sing synthesis".

An external tool that could process a MIDI or MusicXML file created by MuseScore and make an audio file would be good for singers to practise along.

Difficulty: Hard
Skills: C++/Qt
Possible mentor: Nicolas Froment (@lasconic)

Proofing tools for lyrics: spellcheck and hyphenation

Hyphenation is really simple in Spanish (and might be a good starting point), but it is really hyphenation checking in English that is the most valuable (since very few English speakers know how to hyphenate in English).

Hyphenation for lyrics (in English) isn't straight forward. There are plenty of hyphenation algorithms used in desktop publishing and LaTeX but they don't work for lyrics since they disallow one-letter syllables (which is the right choice for end-of-line hyphens but not correct for lyric hyphens, which divide every syllable regardless of letter length). A solution could be to to look up the hyphenation of every word in an English dictionary.

Spell checking lyrics also takes some work beyond simply hooking up a spellchecker. For example "ed-i-tor-in-chief" should pass spellcheck as "editor-in-chief". You have to preserve some hyphens and drop others before the spellchecker recognizes the word.

Ideally these proofing tools would mark up the score directly (with zig-zag underlines, etc.)

Difficulty: Medium
Skills: C++/Qt
Possible mentor: David Bolton

More flexible selection facility

MuseScore currently allows you to select regions and then copy, cut, paste, or delete the contents of that selection. However, the user has no control over which elements within the region are affected. So you cannot choose to copy only the notes but not the lyrics, or only the dynamics, hairpins, and breath markings but not the notes, etc. Other programs provide dialog boxes that allow you to control which element types are affected by operations on that selection. MuseScore could be extended to do this as well.

Difficulty: Easy
Skills: C++/Qt
Possible mentor: Marc Sabatella

Alternate notation styles for specified ranges

MuseScore currently provides a plugin to convert an existing passage into slash notation, but this approach is limited in a number of ways. MuseScore also allows you to specific the transposition for a staff, or to make a staff invisible, or specify the number of staff lines, but these properties are global for the staff throughout the score.

What is desired is to be able to select a region and then specify an alternate notation style for that region - slash notation, a different transposition, different number of staff lines, etc. This involves both defining a UI and mechanism for specifying what you want, as well as actually implementing native support for slash notation and perhaps other notation styles.

Difficulty: Easy to Medium
Skills: C++/Qt
Possible mentor: Marc Sabatella

Design

Current Projects

How to Contribute

If you want to help us design or just give us some design-related feedback, subscribe to our mailing list and drop us a note. If you're shy or don't know what to write, just send an e-mail saying "I want to get involved".

We're always looking for volunteers, so please lend a hand -- no design skills necessary.

How to Design

Before you start designing something, you should get acquainted with our design principles and our branding guidelines.

Once you've done that, look at the "Current Projects" section above and see if there's anything you're interested in. If so, read through our workflow to get a feel for how we work.

Design using Inkscape or another open-source vector editor. Save your work as an SVG. Bitmap editors are not allowed unless you're tweaking photos.

When designing, the icon set might come in handy.

How to Publish

Upload your design to DeviantArt as an SVG and include a PNG preview. If DeviantArt doesn't allow you to post an SVG, at least upload the PNG and put a link to the SVG in its description. Add your design to the #musescore-design group.

The graphics you submit must be published under a Creative Commons license that allows modifications. CC0 works in all situations. By submitting a graphic, you guarantee that all the parts of your graphic are either your own original work or legally reproduced work of others.

If your design falls under the scope of a current project, put it under its Proposals section. If it doesn't, put it on the sandbox. Add your design as a 120px-wide thumbnail linking to its DeviantArt page.

Any questions?

If you have a question or just want to introduce yourself, don't hesitate to write to the mailing list or talk to us on our weekly IRC chat.

Branding

Logotype

Preview Vector file 100x22 bitmap 150x32 bitmap 250x54 bitmap 450x97 bitmap 600x130 bitmap 2000x433 bitmap
MuseScore logo EPS PNG PNG PNG PNG PNG PNG
EPS PNG PNG PNG PNG PNG PNG
EPS PNG PNG PNG PNG PNG PNG

Logomark

Preview Vector file 100x22 bitmap 150x32 bitmap 250x54 bitmap 450x97 bitmap 600x130 bitmap 2000x433 bitmap
EPS PNG PNG PNG PNG PNG PNG
EPS PNG PNG PNG PNG PNG PNG
EPS PNG PNG PNG PNG PNG PNG

Colors

#ee5036 Melody Important aspects
#91336c Rest Silent accenting
#6abed3 Tintinnabulation Links and Invisibles
#8da329 Harmony Sharing, downloading
#2456aa Voice 1
#1a8239 Voice 2
#d79112 Voice 3
#75112b Voice 4

Font

The MuseScore logotype is made by Raúl Posac and set in Neue Helvetica, licensed by Linotype.

The font recommended for use in materials and on the website is Raleway by Matt McInerney.

Design Principles

All designs for MuseScore should be checked against these principles.

These principles are currently mostly copies of those set out by Mozilla.

Layout

ux-discovery

Users should be able to discover functionality and information by visually exploring the interface; they should not be forced to recall information from memory. [Source: Nielsen]

ux-affordance

Controls should visually express how the user should interact with them. [Source: Norman]

ux-natural-mapping

Controls should be placed in the correct location relative to the effect that they will have. [Source: Norman]

ux-visual-hierarchy

Controls that are more important or more commonly used should leverage visual variables such as size and contrast so that they have more dominance and weight relative to other controls.

ux-minimalism

Interfaces should be as simple as possible, both visually and interactively. Interfaces should avoid redundancy. [Source: Minimalism]

ux-userfeedback

Interfaces should provide feedback about their current status. Users should never wonder what state the system is in. [Source: Nielsen]

ux-consistency

All else being equal, software should be internally consistent with itself, and externally consistent with similar interfaces to leverage the user's existing knowledge. [Source: Nielsen]

Behavior

ux-efficiency

Interfaces should be as efficient as possible, minimizing the complexity of actions and the overall time to complete a task. [Source: Nielsen]

ux-control

The software should not automate tasks contrary to the user's intents.

ux-interruption

Interfaces should not interrupt the user. Interfaces should never ask the user a question that they are not prepared to answer simply for a false sense of control. In general, software should only speak when spoken to.

Error Prevention

ux-error-prevention

Interfaces should proactively try to prevent errors from happening. [Source: Nielsen]

ux-undo

Actions should support undo so that users remain in control.

ux-mode-error

Users should not encounter errors because the interface is in a different state than they expected it to be.

ux-error-recovery

Interfaces should proactively help users recover from both user errors and technology errors. (A preferable case is to address through ux-error-prevention so that the error does not occur). [Source: Nielsen]

ux-implementation-level

Interfaces should not be organized around the underlying implementation and technology in ways that are illogical, or require the user to have access to additional information that is not found in the interface itself. [Source: Nielsen, Cooper]

Language

ux-jargon

Users should not be required to understand any form of implementation-level terminology. (This principle is a special case of ux-implementation-level). [Source: Nielsen]

ux-tone

Interfaces should not blame the user, or communicate in a way that is overly negative or dramatic.

IRC chat

We plan to hold an IRC chat every week on the '''#musescore-design''' channel on Freenode. These chats will be key to making final decisions and determining what to focus on next. These chats will be open to everyone, even people who will just read and won't write.

Chats will commence once enough volunteers post to the mailing list.

If you'd like to take part in a chat or two, add your time schedule to our Doodle poll. Ignore the specific dates, take note of only the times and days of the week.

Icon set

Current Icons

The in-progress icon set can be found here.
https://github.com/musescore/MuseScore/tree/master/mscore/data/icons

Specifications

Visual Design

* All icons must be vector-based.
* All toolbar icons must be monochrome with a transparent background.
* Toolbar icons should be 24x24 px with 1px margins.
* If the symbol is narrow, rotate it 45° left or right to fill the focal space.
* All icons must be international and untranslatable. Don't use the "B" symbol for "Bold" or "I" for "Italics", but simply use lowercase "a" with the appropriate formatting applied.
* Keep elements aligned to a square pixel grid for sharpness.

If in doubt, refer to the Gnome icon design guidelines.

Icon Files

* Icons should be submitted in the SVG format.
* Use a single layer only.

Relevant Art

Relevant Art

Ideas for MuseScore UI and website

web.png

Sandbox

Feel free to post your design ideas here.

Theme

A theme for MuseScore 2.0 should be created under the following conditions

  • One theme only for all platforms (Win, Mac, Linux). Our design resources are sparse. The native theme which existed in MuseScore 1.0 has been removed.
  • The MuseScore developers expect a proposal “drawing” by the designer, which can be implemented in C++. Colors and gradient are easy to change, so that doesn't take much time. Shapes, size, etc. require C++ drawing code, takes more time.

Some practical info:

  • Everything is in mstyle directory.
  • The css system which temporary was put in place in the master, only partly worked out. It has been removed again. So everything needs to be coded in C++.
  • An example of how theming is done: line 2341: “p.setColor”

User Interface Text Style Guide

This guide should describe how to design text for the user interface (UI) of the English version of MuseScore.

See OpenOffice.org User Interface Text Style Guide

Website

Subprojects

Structure

  • Homepage
  • About: A little about the history of MuseScore, the current status and where things are going to. Can be same text as on Wikipedia.
    • What is an open source project
    • MuseScore in education
    • Branding
    • Licensing
    • Release history
    • Testimonials
    • References
    • Statistics
    • Contact
  • Documentation
    • Handbook
    • Tutorials
    • How To
    • Use Cases
    • (e)-Books
    • Videos (?)
  • Support
    • Forums
    • IRC
    • Social media: Twitter, Facebook, Identica, YouTube, Flickr, ...
    • Professional services
  • Extensions
    • Plugins
    • Soundfonts
    • Templates
    • Profiles: extension packs for palettes, e.g. for handbells
    • Instruments: personalized and/or localized instruments with cascading instruments.xml
    • Styles: tentative bc taken care off by templates?
    • Languages (in a future stage)
  • Contribute
    • Development
    • Translating (Software & Website)
    • Testing (How to report a bug)
    • Promotion: Help promoting MuseScore. Here is some material you can use to spread the word … Zazzle shop ? http://www.zazzle.com/musescore*
    • Donate

Homepage

Goal

Design a homepage that captures attention and serves as a good starting point for navigating the website.

Status

Call for Proposals
Analyzing Proposals
Shaping Tentative Design
Implementation in Progress
Implemented

Scope

In Scope

  • Download options
  • Feature showcase
  • Screenshots

Out of Scope

  • Change the structure of the website
  • Go against the branding guidelines
  • Leave off the Download button

Proposals

Proposal by Tin Man

Mockups

Workflow

If a project doesn't specify a deadline for a phase, the phase will be one week long, from one IRC chat to the next. If not enough work gets done within the week, the IRC chat attendees may decide to prolong the phase by another week.

Call for Proposals

This week will be dedicated to submitting proposals. A proposal may consist of mockups/sketches and/or textual descriptions, and should be posted under the "Proposal" section of the project. Anyone may submit a proposal, no matter whether they are part of the team or not. Anyone may also add to the "relevant art" section.

End-of-the-week IRC chat

The IRC chat attendees will list problems that haven't been addressed by the submitted proposals, propose solutions, and pick the ones that suit our design principles the most. They will also go through the aspects in which the submitted proposals differ and do the same.

After that is done, they will decide which of them will work on the tentative design. The person chosen will post the solutions that have been decided on under the "Tentative Design" section of the project to serve as an outline for the tentative design. He will then be responsible for mocking it up and fleshing out its description over the coming week.

Shaping the Tentative Design

This week will be spent finetuning the tentative design as it is developed, finding possible bugs, and working together with the developer team to assess how the proposal might be implemented.

Getting started

Your first code contribution

So you want to help develop and improve MuseScore? Welcome to a passionate and dedicated team of volunteers from around the world.

This is how it generally works:

  1. If you see an area that could benefit from improvement, then jump right in!
  2. If you become unsure, ask questions
  3. If you are about to make a significant, or potentially controversial change, discuss it beforehand
  4. Share your improvements early and openly. That way, people can let you know if you're on the right track

How to write a good bug report: step-by-step instructions

MuseScore reports should be based on the latest commit for the forthcoming 2.0 Version and beyond (using a Nightly Build or the source code). 1.3 will not receive further fixes.

Isolate bug

[To be completed]

Check if you are using the latest version

Please check if you are using the latest commit. If not, upgrade and check if the bug still exists.

Check if the bug is known

Please check whether the bug you are experiencing is already documented in the issue tracker. If it is already documented, you may click "subscribe" to follow any developments. If your bug is different than any others recorded in the issue tracker, "Create a new issue".

File each issue separately

If you have multiple issues, it is better to file them separately so they can be tracked easier.

Create a new issue

Sign into MuseScore.org and go to the issue tracker (a link is found on the right side of every page). Click on "Create a new issue".

There are a number of initial questions that are used for filing a bug report - answers to these allow progress.

Project

The first question is which project your bug applies to. If in doubt, select "MuseScore", then "Next" to continue.

Component

Selecting the component is sometimes difficult. When in doubt, select "Code".

Category

A "bug report" is usually for when MuseScore does something contrary to what is expected: An example of a bug could be: open a specific file, but it instead crashes. Almost everything in the issue tracker consists of bug reports.

Tasks, Feature Requests and Support Requests are beyond the scope of this article, but generally, it is recommended discussing it on the forum first, instead of adding directly to the issue tracker.

Priority

A bug is generally only considered "critical" priority if any of the following happens:

  • Data loss
  • Corruption
  • Score no longer opens
  • Inability to save work
  • Certain irreversible operations
  • Hangs and crashes

All other bugs are considered "normal" or "minor" priority. Bear in mind that a bug that you are experiencing is important to you, but developers have to balance it with all the other known bugs.

Status

The status of new bug reports should generally be marked as "Active".

Assign

If you intend to provide a fix, you can select your username. If otherwise, leave it 'unassigned'.

Title

The title should describe the problem as best as possible. Remember that the title is read more often than any other part of the bug report.

Poor title: Notes don't display correctly
This title is not specific enough for someone to look at it a month from now, and remember what the bug report is referring to.

Good title: Stems too short for 32nd and 64th notes
This title is an improvement over the previous title, because it specifies the type of notes that are affected and identifies the display problem.

After submitting the issue, it is possible to improve the title.

Description

Steps to reproduce bug

A bug report requires clear instructions, so that others can consistently reproduce it. Many bugs require some experimentation to find the exact steps that cause the problem you are trying to report. If you aren't able to discover these, try obtaining some help on the forums instead.

A good set of instructions includes a numbered list that details each button press, or menu selection. The following bug reports are good examples to mimic:

Note: the following bugs have all now been fixed

It can also be helpful to test your own instructions, as though someone else is trying them (as they will).

Expected behavior

Describe what should happen if the bug was fixed.

Actual behavior

In contrast to the expected behavior, describe what currently happens when the bug is present.

Version number

In MuseScore, go to About (listed in a top menu, depending on your operating system) to find out the version of MuseScore you are using. For example: "Revision 5375, Nightly Build".

The commit code can be obtained via 'About' and clicking the 'Copy to clipboard' button, or in 'Help'>'Report a bug'.

Alternately, please state if you have compiled the source code and detail the versions of the third party tools.

Operating system

Name the operating system and version you are using, such as "Windows XP SP3", or "Mac OS X 10.7.5".

File Attachments

If you can supplement your bug report with an image, audio, score or log that helps others reproduce the issue, attach these files.

Tools

You can use this bookmarklet to automatically create a template for a bug report. It will obtain the last SHA from github and create a list of steps.

Submit

"Save" to submit your bug report to the issue tracker.

Responses

When a bug is fixed, there are some terms used. Here are their definitions:

Branch
This is the code for the next minor release of MuseScore, which is based on the current stable version - it usually contains bug fixes.
Master or Trunk
This is the code for the next major release of MuseScore - it usually contains both new features and bug fixes.

Once a developer marks a bug as fixed, it is a good idea to ensure that it is completely fixed. To test, visit the Download page for the instructions to compile the source code, or to download a nightly build.

How to use a debug version of MuseScore

A special "debug" version of MuseScore displays messages about each step that is happening inside the software. It can be useful for finding the source of bugs or problems with the software. The instructions below show how to use a debug version that is pre-built.

Important: the debug version is not a stable release and is only intended for testing a specific problem. Please use other versions of MuseScore for creating or editing normal scores.

Instructions for Windows

Download the "debug" version of MuseScore.
http://prereleases.musescore.org/windows/nightly/mscore-debug.7z

After you download the file you will need to decompress the file using 7-Zip (as explained on the Windows nightly builds page).

When the "debug" version is running it displays detailed information in a separate window called a "command prompt". The "command prompt" usually appears as a small window with white text on black background.

  1. Open the uncompressed "mscore-debug" folder
  2. Double-click "runDebug.bat". This should open the main MuseScore window and the debug window
  3. Follow the exact steps that are causing problems for you in MuseScore and then choose File > Quit

The command prompt should remain open after you close the main MuseScore window. It is sometimes helpful to share the contents of the command prompt text when discussing a bug. However the text is often lengthy so it is probably best to only share it if requested or if you notice something important. Copying text from the command prompt is different from any other program in Windows so the remaining steps describe this procedure.

  1. Right click on the command prompt window and choose "Mark"
  2. Click and drag to select the text. Make sure you get all the text
  3. Press Enter. The text is now copied
  4. You can now paste this text in other programs via the normal methods (Edit > Paste)

Command line options

You can launch MuseScore from the command line by typing

mscore <options> <filename>

<options> and <filename> are optional.

The following options are available

-v
Displays the current version and revision numbers for MuseScore (Linux only)
-d
Starts MuseScore in debug mode
-D
Enables the plugin script debugger
-s
Disables the integrated software synthesizer
-m
Disables MIDI input
-n
Starts with the new score wizard regardless of preference setting for start mode (0.9.6 or later)
-L
Starts MuseScore in debug layout mode
-I
Displays all MIDI input on the console
-O
Displays all MIDI output on the console
-o <filename>
Exports the currently opened file to the specified <filename>. The file type depends on the filename extension. This option switches to the "converter" mode and avoids any graphical interface. You can also add a filename before the -o if you want to import and export files from the command line. For example mscore "My Score.mscz" -o "My Score.pdf"
-r <dpi>
Determines the output resolution for the output to "*.png" files in the converter mode. The default resolution is 300 dpi
-S <style>
Loads a style file; useful when you convert with the -o option
-p <name>
execute named plugin
-F
Use only the standard built-in presets or "factory-settings". For details, see Revert to factory settings
-e
Enable experimental features
-i
Load icons from the file system. Useful if you want to edit the MuseScore icons and preview the changes
-w
writeWorkspaceFile and converterMode
-c <pathname>
set config path
-t
enable Test Mode
-a <driver>
use audio driver: jack alsa pulse portaudio

Qt Toolkit Options

-style = style
Determines the style of the GUI application. Possible values are "motif", "windows" and "platinum". Depending on the platform other styles may be available
-style style
As above
-stylesheet = ss
Sets the application stylesheet. The value of "ss" is a path to a file that contains the stylesheet
-stylesheet ss
As above

Translating MuseScore

The translation server plays the central role in localizing MuseScore. It's the translation server which is in charge of committing the translations to the code repository and the translation server only.

Help translating

Translating MuseScore is done via the web interface of the translation server at http://translate.musescore.org. This is done collaboratively by translating string per string. In the future it will also be possible to import a complete po file.

Technical workflow

  • The translation server will hold a release for each stable MuseScore version. These are never updated. The trunk on the other hand is checked out on daily basis.
  • For each release and language, there will be a qm file available so the latest version can be tested locally by download the qm file into the MuseScore directory.
  • At regular times, the ts files of the trunk release will be committed to the repository.

Compilation

Compile instructions (Windows - MinGW) - Git

Introduction

From revision 3e5b91d onwards, committed 20 May 2014, the development version of MuseScore on Windows requires Qt 5.3.0 and a C++11 capable toolchain.

To prevent any compatibility issues, it is essential to compile MuseScore with the same type and version of compiler as was used to build Qt.

N.B. The instructions on this page are only applicable to MuseScore from the above revision onwards. If you are compiling MuseScore 1.2, or an older revision of the git repo, you need to follow the older version of these instructions, as it may require different versions of Qt and GCC. Note that MuseScore requires Qt > 5.1 only. The build process is hardwired to use the most recent version of Qt but can be downgraded easily by changing build/mingw32.ming.cmake and making sure that the correct DLLs are installed.

What you need

Tools

The following tools need to get installed on your computer.

7-Zip utility

Some of the files to be downloaded are compressed using 7-Zip compression. If necessary, download and install 7-Zip.

MinGW 4.8.2 and Qt 5.3

Download the Qt Online Installer for Windows.

NB There a number of Windows installers on this page - make sure it is the Online Installer you are downloading. MuseScore is known to work with 5.3.

Run the installer and install Qt in C:\Qt. You just need the Qt libraries for MinGW 4.8.2 and the MinGW 4.8.2 toolchain.

shot_140520_145208.png

(optional) Add the following to your %PATH%

C:\Qt\Tools\mingw482_32\bin;C:\Qt\Tools\mingw482_32\lib
C:\Qt\5.3\mingw482_32\bin
C:\Qt\Tools\QtCreator\bin
CMake 2.8

Download the latest version of windows binaries for CMake 2.8. Choose the Windows (Win32 Installer) version.

Install in the default location (probably C:\Program Files\CMake 2.8 or C:\Program Files (x86)\CMake 2.8) and optionally put the bin subdirectory in your PATH.

Optional Tool : NSIS unicode

NSIS unicode is used to create the install package itself. It's not needed if you just want to develop.

Optional Tool: doxygen

doxygen is used to generate developer documentation from the source files. It is not needed to compile the program, but if you plan to develop the generated documentation can aid understanding the classes and class hierarchies.

Download the native windows doxygen installer from www.doxygen.org

Note: there have been reports that the cygwin doxygen package has issues generating MuseScore developer documentation, and so it is recommended to use the native windows doxygen instead.

Source Code

Get the source code from GitHub. If you need a Git client, you can try Git for Windows or the GitHub windows client.
git clone git://github.com/musescore/MuseScore.git

If you plan to contribute to MuseScore, you can setup your own fork on GitHub and clone it instead. See the Git Workflow page.

Note: Directory names with spaces in them cause the build to fail; so avoid spaces in the name of your clone directory.

(optional but recommended) In your clone directory, copy the file build/git/hooks/post-checkout to the directory .git/hooks in order for mscore/revision.h to be maintained automatically by git. See build/git/hooks/README for details.

Change default paths (optional)

The following two steps should not be necessary if using the default paths given above for Qt and MinGW.
Change build\mingw32.mingw.cmake to suit your Qt and mingw install

set (CROSS C:/Qt/Tools/mingw482_32)
set (CROSSQT C:/Qt/5.3/mingw482_32)

%PATH% summary

You must have the following in your %PATH%:

  • C:\Program Files\CMake 2.8\bin (or wherever you installed CMake)
  • C:\Qt\Tools\mingw482_32\bin;C:\Qt\Tools\mingw482_32\lib (or wherever MinGW is installed for you)
  • C:\Qt\5.3\mingw482_32\bin (or wherever Qt is installed for you)
  • And if you want to launch QtCreator from the command line C:\Qt\Tools\QtCreator\bin

NOTE: You can add path elements to cmd shells via Computer / System Properties / Advanced System Settings / Environment Variables. However, the make process can be sensitive to the rest of the contents of your %PATH% as well. If you encounter issues like mingw32-make immediately terminating with error code 0xc00000fd, then try stripping your path down to only the above elements, plus perhaps C:\Windows and C:\Windows\System32. You might consider running the build from a batch file that temporarily sets your %PATH% to just the required elements.

A good approach to doing so is to create the following batch file:

C:\Qt\qt.bat

@echo off
echo Setting up a MinGW/Qt only environment...
echo -- Set QTDIR to C:\Qt\5.3\mingw482_32
set QTDIR=C:\Qt\5.3\mingw482_32
echo -- Set PATH to %QTDIR%\bin
set PATH=%QTDIR%\bin
echo -- Adding C:\Program Files (x86)\CMake 2.8\bin
set PATH=%PATH%;C:\Program Files (x86)\CMake 2.8\bin
echo -- Adding C:\Qt\Tools\mingw482_32\bin;C:\Qt\Tools\mingw482_32\lib to PATH
set PATH=%PATH%;C:\Qt\Tools\mingw482_32\bin;C:\Qt\Tools\mingw482_32\lib
echo -- Adding to C:\Qt\Tools\QtCreator\bin
set PATH=%PATH%;C:\Qt\Tools\QtCreator\bin
echo -- Adding %SystemRoot%\System32 to PATH
set PATH=%PATH%;%SystemRoot%\System32
echo -- QMAKESPEC set to win32-g++
set QMAKESPEC=win32-g++
cd %USERPROFILE%
echo -- Set MAKEFLAGS to -j %NUMBER_OF_PRCESSORS%
set MAKEFLAGS=-j %NUMBER_OF_PROCESSORS%
rem un-rem the following line to start Qt Creator immediately
rem using /low makes sure you can still work with the PC
rem -lastsession gets you back where you left
rem start /low qtcreator -lastsession

Then create a shortcut to this batch file somewhere in the Programs menu. If starting QtCreator immediately, the shortcut can be set to "Start minimized".

Dependencies

In addition to Qt, MuseScore depends on:

  • portaudio to access windows audio...
  • JACK to connect to JACK Server for MIDI and audio
  • libsndfile for wav/ogg/flac output
  • Ogg and Vorbis for support of ogg soundfonts
  • LAME for support for MP3

I choose to put these dependencies directly in the MinGW include path. It's ugly but convenient. Either follow the below instructions or take Qt-additions.zip and unpack it into C:\

libVorbis, libVorbisFile, libOgg

The latest source also requires libraries for Vorbis and Ogg.

  1. Get the library files for libVorbis and libOgg from: http://www.xiph.org/downloads
  2. Copy the directories: include\vorbis and include\ogg into C:\Qt\Tools\mingw482_32\i686-w64-mingw32\include (Copy the entire directory so that you end up with C:\Qt\Tools\mingw48_32\i686-w64-mingw32\include\vorbis and C:\Qt\Tools\mingw482_32\i686-w64-mingw32\include\ogg)
  3. Get the Vorbis Tools and copy libogg.dll, libvorbis.dll and libvorbisfile.dll in C:\Qt\Tools\mingw482_32\lib (You need to decompress the .7z file using 7 Zip)
Portaudio
  1. Get portaudio.dll from a previous MuseScore install (bin directory) and copy to C:\Qt\Tools\mingw482_32\lib
  2. Get portaudio.h from the current version at http://www.portaudio.com/download.html and copy to C:\Qt\Tools\mingw48_32\i686-w64-mingw32\include. You need to decompress the .tar.gz file using 7 Zip, as before.
JACK
  1. Download the Windows installer for JACK from http://jackaudio.org/downloads
  2. Install
  3. The build process assumes you installed in a directory Jack in your program files directory. The name of the program files directory can vary depending on the version and language of Windows. The environment variable %ProgramFiles% or %ProgramFiles(x86)% is used to find the directory. On an English version of Windows this will result in looking in C:\Program Files\Jack or in C:\Program Files (x86)\Jack on a Windows 64-bit
libsndfile
  1. Windows binary available, choose Win32 http://www.mega-nerd.com/libsndfile
  2. Install and go to the installation directory. The installation process is required to be run in administration mode.
  3. Copy include\sndfile.h into C:\Qt\Tools\mingw482_32\i686-w64-mingw32\include
  4. Copy bin/libsndfile-1.dll into C:\Qt\Tools\mingw482_32\lib
LAME
  1. Download the current source files for LAME: http://lame.sourceforge.net/download.php
  2. You need to decompress the .tar.gz file using 7 Zip, as before
  3. Create a new folder in the C:\Qt\Tools\mingw482_32\i686-w64-mingw32\include directory called lame
  4. Copy include\lame.h into C:\Qt\Tools\mingw482_32\i686-w64-mingw32\include\lame

Compilation

If you wish to use the QtCreator IDE, follow the instructions in section "Qt Creator IDE", below.

Open a command line, possibly using a batch file such as qt.bat given above.
Browse to the directory where you checked out musescore
Enter

mingw32-make -f Makefile.mingw release

or

mingw32-make -f Makefile.mingw debug

Note that the two options internally set different flags for the compiler. In debug mode the QT_DEBUG flag is used, so conditional code controlled by #ifdef QT_DEBUG is compiled. In release mode NDEBUG is set. Unless you are building a release, it is suggested that you use the "debug" option, like in the section on the Qt Creator IDE (below).

Be patient ... On my Vista laptop (Intel T7550) it takes more than one hour to build. Build times on Windows can be more than twice as long as build times on Ubuntu (using the same computer). Once the compilation finishes, the MuseScore executable can be found in build.release/mscore/mscore.exe or build.debug/mscore/mscore.exe. So long as C:\Qt\Tools\mingw48_32\lib is in the PATH, it should not be necessary to copy any DLLs. However, it has been found necessary to copy the complete directories iconengines and imageformats from %QTDIR%\plugins to the build.release/mscore or build.debug/mscore directory (resulting in, for example, build.debug/mscore/iconengines. This should be sufficient for most development work.

Note: You may need to go into the preferences, and fix the paths to have Windows-style slash characters (backslash), or you may see error messages about not being able to open files. [Is this a bug?]

If you need the language files, instrument list, templates, and the normal directory structure of a installed version of MuseScore then type:

mingw32-make -f Makefile.mingw install

or, for a debug build:

mingw32-make -f Makefile.mingw installdebug

Once install has finished look in the current directory for win32install/bin/mscore.exe. In this case there is no need to copy DLLs or the plugins directories, as they are already copied during the make process.

If you need developer documentation for MuseScore then after compiling, type:

cd build.release
mingw32-make doxy

The generated documentation can be viewed by opening win32build/Doc/html/index.html in a browser.

Qt Creator IDE

Once you setup everything above, you can open Qt Creator, either by typing start qtcreator from within a command prompt started as above, or by creating a separate batch file with start qtcreator as the last command.

Go to File => Open File or Project....

Now it will take you through a pathwizard:

  1. Build Location:
    Choose CmakeLists.txt file type and open the file CmakeLists.txt from your source directory.
    For the first Cmake run, it will offer a build directory such as MuseScore-build, if MuseScore is your checkout directory. Change this to choose a build directory of MuseScore/build.qtc instead.
    Please make sure the name of your build directory does not contain spaces.
  2. Choose CMake Executable:
    Browse to where you installed CMake (i.e. C:\Program Files (x86)\CMake\bin)
  3. Run CMake:
    Then input the following arguments for CMake:

    -DCMAKE_BUILD_TYPE=DEBUG -DCMAKE_TOOLCHAIN_FILE=build/mingw32.mingw.cmake -DCMAKE_INSTALL_PREFIX=../win32install

As for the manual build, the supplementary DLLs should be found via C:\Qt\Tools\mingw48_32\lib in the PATH, so no further setting of environment variables should be required.

Before your first build or debug session, you will need to configure the Build, Deploy, and Run steps. Click Projects at left, then Build toward the top of the screen. Under Build Steps, expand the Details button and add a checkmark next to the lrelease target.
Then go back to the top of the screen and click Run. On this screen, you will first need to click Add Deploy Step. Select Make, then select install under Targets. Finally, you will need to click the Add button under Run Configuration to add a custom executable, and set it to win32install\bin\mscore.exe under your main source folder.

To compile the debug build and start debugging go to Debug => Start debugging => Start debugging or simply click the debug icon. You have access to Qt help, completion, and debugging features!

Known problems

Note that there is a bug in the Qt Creator debugger. In some cases it will crash when a QPrinter object is instantiated (http://bugreports.qt-project.org/browse/QTBUG-14048). This happens when you print (of course!).

Compile instructions (Mac OS X) - Git

Use these instructions to compile MuseScore on Mac OS X 10.7 (Lion) and 10.8 (Mountain Lion). The binary will run on 10.7 and above. Instructions and binaries are for Mac 64-bit.

Setting the build and development environment

  1. On Mac OS X 10.8+, install the last version of Xcode from the Mac App Store. On Mac OS X 10.7, install Xcode 4.6 from Apple Developer (latest version available from Mac App Store doesn't work on 10.7)
  2. Launch Xcode and accept the licence
  3. In Xcode, go to Preferences -> Download and install the Command line Tools. With XCode 5, you might need to run xcode-select --install instead.
  4. Install the dependencies. If you prefer Homebrew,
    $ ruby -e "$(curl -fsSL https://raw.github.com/Homebrew/homebrew/go/install)"
    $ brew install libogg libsndfile libvorbis pkg-config portaudio jack lame cmake git
    
  5. If you prefer MacPorts, choose the DMG of your OS and install MacPorts
    Open a terminal and enter the following (in your home):

    $ sudo port install git libsndfile pkgconfig lame portaudio jack cmake
    
  6. Qt 5.3 is shipped as a online installer, suitable for 10.7+. Download, open the DMG and run the online installer. By default it will install Qt 5.3 in your home directory.
  7. Open a terminal and enter the following (in your home):
  8. Append the following line to ~/.profile
    PATH=$PATH:~/Qt/5.3/clang_64/bin

    and run

    source ~/.profile
  9. If you use Qt 5.1.0, it has a packaging bug that will impact MuseScore packaging. If you plan to package MuseScore, run
    cd Musescore/build
    ./fix_qt51_mac.sh  ~/Qt/5.1.0/clang_64
    

    It will fix Qt libraries and plugins.

  10. Clone the repository from GitHub:
    git clone git://github.com/musescore/MuseScore.git
    

    If you plan to contribute to MuseScore, you can setup your own fork on GitHub and clone it instead. See the Git Workflow page.

Building MuseScore

  1. In a terminal, enter:
    cd MuseScore
  2. Set the revision SHA1 for this build
    make revision
  3. Start the actual compilation. It takes more than one hour on a MacBook 2 GHz
    make -f Makefile.osx release
  4. Call the install target. The bundle is copied from the Release directory into the applebuild directory. All resources (such as help and templates) are added to it
    make -f Makefile.osx install
  5. The package step. This target calls a script derived from this one. It creates a self-contained bundle, thanks to macdeployqt, by adding and stripping the Qt libraries into the MuseScore bundle. It also adds Qt plugins, PortAudio and libsndfile. A DMG file is the result
    make -f Makefile.osx package

Debugging and developing MuseScore

If you are a developer, look at the xcode target in the makefile. It generates a xcodeproj file. You can open this xcodeproj file and use the Apple IDE for tasks such as modifying, debugging and compiling MuseScore code.

Run

make -f Makefile.osx xcode

Then open the xcodeproj bundle in Xcode

open build.xcode/mscore.xcodeproj

In XCode, run the ALL_BUILD scheme. It will compile all the files. Then run the install scheme. It will install the required files (fonts, images etc...) for runtime. Debug by running the mscore scheme.

In XCode 5, you might need to uncheck “Allow debugging when using document Versions Browser” in Product-->Edit Scheme .. -->Run mscore.app. Otherwise --NSDocumentRevisionsDebugMode YES gets passed to MuseScore, and it doesn't know how to handle it.

The prefered way to contribute is via a Pull Request on GitHub. Patches are also welcome on the Developer Mailing List, or on the Issue Tracker.

Compile instructions (Mac OS X 10.5) - SVN trunk

Here are the steps to create an universal binary from MuseScore SVN trunk.
Please note that some steps might not be required but I document them because it works on my system by following them.
These instructions have been tested on Mac Intel with Mac OS X 10.5.8.

Overview

The whole build process takes 1 hour and 30 minutes on a Macbook 2GHz. Downloading and installing all the tools and dependencies can take one hour more but it's just a one time process.
The result of the build process is a DMG file ready to be distribute and suitable for PPC and Intel on Mac OS X Tiger and Leopard.

Setup the build and development environment

  1. Install the Developer Tools from Apple. They are included with OS media. Developer Tools includes a command line svn client and Xcode, the Apple IDE. The last version for 10.5 is Xcode 3.1.4 Developer Tools.
  2. Open a terminal and in your home
    mkdir musescore
    cd musescore
    svn co https://mscore.svn.sourceforge.net/svnroot/mscore/trunk mscore 
    
  3. Install Cmake 2.8.2. The dmg installation is ok.
  4. Install Qt SDK 4.6 from the dmg file. Choose the SDK not the Framework only download.
  5. Install macports 1.9.1. Dmg is fine as well.
  6. Configure macports to install 10.4 compliant ports by changing these lines in /opt/local/etc/macports/macports.conf
    universal_target  10.4
    universal_sysroot      /Developer/SDKs/MacOSX10.4u.sdk
    
  7. In a terminal, install portaudio and libsndfile with macport. Pkgconfig is also required to help cmake finding these libs.
    Note the +universal for libsndfile to generate universal binaries. It's default for portaudio apparently.

    sudo port install pkgconfig
    sudo port install portaudio
    sudo port install libsndfile +universal
    sudo port install lame
    
  8. Install JackOSX and copy the pkgconfig file to the good place.

    sudo cp /usr/local/lib/pkgconfig/jack.pc /opt/local/lib/pkgconfig/
    

Build MuseScore

  1. In a terminal, go into mscore directory
    cd ~/musescore/mscore
  2. Set the revision number for this build.
    make revision
  3. Start the actual compilation. It takes more than 1 hour on macbook 2Ghz
    make -f MakeFile.osx release

    if you are a developer, take a look to the release target in the makefile. You'll see that it generates a xcodeproj file and calls xcodebuilder to build it as a command line. Of course, you can open this xcodeproj file and enjoy the Apple IDE to modify MuseScore code, correct bugs, compile, debug etc... Patches are welcome on the dev mailing list.

  4. Call the install target. The bundle is copied from Release directory into applebuild directory. All resources (help, templates etc...) are added to it.
    make -f MakeFile.osx install
  5. Package step. This target calls a script derived from this one. It creates a self contained bundle thanks to macdeployqt by adding and stripping the Qt libraries into the MuseScore bundle. It also adds Qt plugins, portaudio and libsndfile. A dmg file is created with a nice background and well positioned icons.
    make -f MakeFile.osx package

Happy building!

Compile instructions (Ubuntu 12.04) - Git

The following steps explain how to build and install MuseScore trunk on Ubuntu 12.04 Precise Pangolin.
These instructions have been tested on a clean Ubuntu server distrib.

Install GCC 4.7+

GCC 4.7 or higher is needed. On Ubuntu 12.10 and higher, it's the default compiler. On Ubuntu 12.04, you will need to install it.

sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
sudo apt-get  update
sudo apt-get install g++-4.8
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.8

Install Qt 5.3.1

Download and install Qt 5.3 from http://qt-project.org/downloads
Add Qt bin directory in your $PATH.

For 32-bit:

echo "PATH=~/Qt5.3.1/5.3.1/gcc/bin:$PATH" >> ~/.bashrc
source  ~/.bashrc

or for 64-bit:

echo "PATH=~/Qt5.3.1/5.3.1/gcc_64/bin:$PATH" >> ~/.bashrc
source  ~/.bashrc

Install dependencies

sudo apt-get install git cmake
sudo apt-get install alsa libsndfile1 
sudo apt-get install libasound2-dev portaudio19-dev libsndfile1-dev zlib1g-dev libfreetype6-dev
sudo apt-get install lame libmp3lame-dev

In Ubuntu 13.04 you need to install these additional libraries:

sudo apt-get install libdrm-dev libgl1-mesa-dev

Note: In some cases, libgl1-mesa-dev(and/or libegl1-mesa-dev) needs to be installed in Ubuntu 12.04 desktop edition too. Install this library if you get the following error while making:

Failed to find "GL" in "".

Optional


sudo apt-get install libpulse-dev
sudo apt-get install doxygen

Get the source code and compile

git clone git://github.com/musescore/MuseScore.git
cd MuseScore
make revision
make
sudo make install (or just run build.release/mscore/mscore if you don't want to install it each time)

If you run into any errors after running "make", be sure to run this before starting over:

make clean

If you plan to contribute to MuseScore, you can setup your own fork on GitHub and clone it instead. See the Git Workflow page.

Keep the source code up to date...

cd MuseScore
git pull

Uninstall

Cmake doesn't provide a uninstall target by default but you can run:

 xargs rm < install_manifest.txt

Qt Creator IDE

  • Open ./CMakeLists.txt as your project file.
  • When QT Creator asks for command line options for cmake, use
    -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=DEBUG
  • When QT Creator asks to Choose CMake Executeable, it's probably located at
    /usr/bin/cmake

Debug with Eclipse CDT

  1. Download Eclipse CDT bundle or install the CDT on a previous eclipse install.
  2. Edit ./CMakeLists.txt and change Project name to something different than "mscore" (if not, Eclipse will not find the mscore binary to run)
  3. Create a musescore_build directory in the workspace and run Cmake to generate Eclipse project
    mkdir musescore_build
    cd musescore_build
    cmake -G"Eclipse CDT4 - Unix Makefiles" -D CMAKE_BUILD_TYPE=Debug ../MuseScore
  4. Open Eclipse.
    • Import project using Menu File->Import
    • Select General->Existing projects into workspace
    • Browse where your build tree is and select the root build tree directory. Keep "Copy projects into workspace" unchecked.
    • You get a fully functional eclipse project. Be patient, Eclipse will index all cpp files and build the project.
  5. To debug, right click on the project and choose Debug as -> Local C/C++ Application
  6. Go to debugger tab, share libraries tab and uncheck Load shared library symbols automatically and Stop on shared library events
  7. You should be able to debug.
  8. If you lack sound, in Preferences->I/O, you can try to check PortAudio, APi: Alsa, Device: Pulse
  9. More information: http://www.cmake.org/Wiki/Eclipse_CDT4_Generator

Compile instructions (Ubuntu 9.10) - SVN trunk

This page is deprecated and kept for reference. The current development of MuseScore is done on Git and the SVN repo is abandoned. You can find instructions to build the most up to date version in the developer handbook

The following steps explains how to build and install MuseScore trunk on Ubuntu 9.10 Karmic Koala.
These instructions have been tested on a clean Ubuntu server distrib.

Qt 4.7 PPA: deb http://ppa.launchpad.net/kubuntu-ppa/backports/ubuntu lucid main

Setup build environment

  1. Update your repository sources.
    sudo apt-get update
  2. Install Subversion
    sudo apt-get install subversion
  3. Get MuseScore last source code
    mkdir musescore
    cd musescore
    svn co https://mscore.svn.sourceforge.net/svnroot/mscore/trunk .
    cd ..
  4. Get Qt 4.6. This is only necessary if you are running Ubuntu Karmic without any mscore PPA. Otherwise, skip the next (four) steps until "Install MuseScore dependencies" below.
    If you are running a 32-bit OS
    wget http://get.qt.nokia.com/qtsdk/qt-sdk-linux-x86-opensource-2010.05.1.bin
    chmod a+x qt-sdk-linux-x86-opensource-2010.05.1.bin

    If you are running a 64-bit OS
    wget http://get.qt.nokia.com/qtsdk/qt-sdk-linux-x86_64-opensource-2010.05.1.bin
    chmod a+x qt-sdk-linux-x86_64-opensource-2010.05.1.bin
  5. Install Qt4.6. User home is fine. Install everything
    If you are running a 32-bit OS
    ./qt-sdk-linux-x86-opensource-2010.05.1.bin
    If you are running a 64-bit OS
    ./qt-sdk-linux-x86_64-opensource-2010.05.1.bin
  6. Put qmake in the $PATH
    Append the following to ~/.bashrc
    if [ -d ~/qtsdk-2010.05/qt/bin ] ; then
    PATH=~/qtsdk-2010.05/qt/bin:"${PATH}"
    fi

    Then run
    source .bashrc
  7. As written at the end of Qt installation process, install Qt dependencies
    sudo apt-get install libglib2.0-dev libSM-dev libxrender-dev libfontconfig1-dev libxext-dev

Install MuseScore dependencies

sudo apt-get build-dep musescore

If this magic command doesn't work, try to install the following dependencies manually:

  1. ALSA
    sudo apt-get install alsa
    sudo apt-get install libasound2-dev
  2. Libsndfile for flac, ogg, wav export
    sudo apt-get install libsndfile1
    sudo apt-get install libsndfile1-dev
  3. Portaudio (optional)
    sudo apt-get install portaudio19-dev

Build

Type the following to compile and install MuseScore. It will take quite some time to compile. On a 1.7Ghz CPU, it takes more than an hour.
cd musescore
make revision
make release
sudo make install

Further upgrades

Are easier... Use the update subcommand of svn and don't forget make revision to have the right revision number in the about box.
If the build environment didn't change (Qt version etc...), type the following

svn update
make revision
sudo make install

If you want to build from scratch :
cd musescore
svn update
make clean
make revision
make release
sudo make install

Debug with Eclipse CDT

  1. Download Eclipse CDT bundle or install the CDT on a previous eclipse install.
  2. Check out MuseScore code from SVN in Eclipse into a directory named "musescore". You'll need a source tree linked to SVN in your workspace to get updates.
  3. Edit mscore/CMakeLists.txt and change Project name to something different than "mscore" (if not, eclipse will not find the mscore binary to run)
  4. Create a musescore_build directory in the workspace and run Cmake to generate Eclipse project
    mkdir musescore_build
    cd musescore_build
    cmake -G"Eclipse CDT4 - Unix Makefiles" -D CMAKE_BUILD_TYPE=Debug ../musescore
  5. Open Eclipse.
    • Import project using Menu File->Import
    • Select General->Existing projects into workspace
    • Browse where your build tree is and select the root build tree directory. Keep "Copy projects into workspace" unchecked.
    • You get a fully functional eclipse project. Be patient, Eclipse will index all cpp files and build the project.
  6. To debug, right click on the project and choose Debug as -> Local C/C++ Application
  7. Go to debugger tab, share libraries tab and uncheck Load shared library symbols automatically and Stop on shared library events
  8. You should be able to debug.
  9. If you lack sound, in Preferences->I/O, you can try to check PortAudio, APi: Alsa, Device: Pulse
  10. More information: http://www.cmake.org/Wiki/Eclipse_CDT4_Generator

    Qt Creator IDE

    • open mscore/CMakeLists.txt as your project file.
    • when QT Creator asks for command line options for cmake, use
      -G"Unix Makefiles" -D CMAKE_BUILD_TYPE=Debug ../mscore

Compile instructions (Ubuntu) - 0.9.3

Here are the required steps for compiling 0.9.3 on Ubuntu 8.04 Hardy:

First install the required dependencies (if you do not already have them)

sudo apt-get build-dep mscore

Download the .tar.bz source from Sourceforge, uncompress, compile and install :

bunzip2 mscore-0.9.3.tar.bz2
tar xf mscore-0.9.3.tar
cd mscore-0.9.3

make

[go drink a coffee until it's finished]

cd build
make lupdate
make lrelease
sudo make install

Hint:
the revision of cmake coming with ubuntu (currently 2.4) may be not sufficient. To build mscore cmake rev. 2.6 is required.
Set the following two variables in mscore/CMakeLists.txt to false;

set(BUILD_SCRIPT_INTERFACE false) # this requires qt >= 4.4 && cmake 2.6
set(BUILD_SCRIPT_DEBUG false)

To set

set(QT45 false) # set to true if you use qt >= 4.5.0

may be also helpful.

Compile instructions (Fedora 16) - Git

The following steps explain how to build and install MuseScore trunk on Fedora 16. These instructions have been tested on a clean Fedora 16 64bit distrib.

Install dependencies


sudo yum install git
sudo yum install make
sudo yum install cmake
sudo yum install qt-devel qtwebkit qtwebkit-devel
sudo yum install libsndfile-devel
sudo yum install libsndfile
sudo yum install lame-devel
sudo yum install lame
sudo yum install libogg-devel libvorbis-devel
sudo yum install portaudio-devel
sudo yum install pulseaudio-libs-devel
sudo yum install gcc gcc-c++

See Compile instructions (Ubuntu 12.04) - Git for instructions to compile the code and use Qt Creator.

Notes for Fedora 16 32 bit.

If you have problem with building Musescore on Fedora you can read this page.

Finding your way around

Testing

Automated testing

MuseScore does not yet have any automated tests set up. Below are some notes to help keep track of some possible options.

Ubuntu / Linux

Windows

Cross platform

  • Systir. Tests written by hand in Ruby.

Exploring code and data structures

How to get started

After you have downloaded a Nightly Build or made you own version, you are ready to explore data structures and code.

In a score right click on a note or any other item and select "Object Debugger" from the right-click menu. This will give you an opportunity to explore the data structures.

Also, there is "Edit > Debugger", that lets you explore the data in a score.

Getting started in the source tree

The main part of the code lives in mscore/mscore and mscore/libmscore. A good point to start exploring is mscore/mscore/musescore.cpp. This is also where the main() function is located. In MuseScore::cmd commands are processed. Most commands that modify the score are passed off to ScoreView::cmd in scoreview.cpp.

If you put a breakpoint in ScoreView::cmd, you can find and then step into the function that processes a specific command.

Commands like cut, copy, paste are posted as a new event right at the start of ScoreView::cmd. These events are then processed in ScoreView:normalCut, ScoreView:normalCopy, ScoreView:normalPaste. The paste execution ends up in mscore/libmscore/cmd.cpp Score::cmdPaste. Note that copy and paste put content onto the clipboard through the interface provided by Qt (in ScoreView::normalCopy()).

Quite a few commands, like changing the duration of a note, are handled right at the end of this function where _score->cmd() is called.

In mscore/libmscore you find the source for the various classes and the layout algorithm. If you sort the directory by file size, you'll easily spot where most processing is done: measure.cpp, score.cpp, cmd.cpp, undo.cpp., layout.cpp. edit.cpp and chord.cpp.

Finding crashes

Crashes are annoying to users and don't shed a good light on the software. Generally, all crashes are classified as "critical" bugs in the issue tracker.

Crashes can be divided into two categories. Program errors where the operating system stops the further execution of a program, because the program has attempted to perform an illegal operation (for example a reference through a null pointer, accessing an non-allocated address or even a divide by zero). The other category is where the program logic tries to detect invalid conditions. That can either be in the MuseScore application code, or in the underlying Qt runtime. Qt provides a macro Q_ASSERT (). If during program execution the condition isn't met, a message is printed to the console (with qFatal) and the execution is aborted with abort(). The Qt runtime internally uses Q_ASSERT; MuseScore application code uses both Q_ASSERT and abort(), typically after printing a debug message to the console with (qDebug or qFatal). In Windows, that looks like this:
crash-image.png

The crashes in the first category are usually easy to find. The debugger will just stop and show you the location of where the exception occurred in the call stack. You then inspect the program logic. If no apparent solution springs to mind, you report your analysis in the issue tracker.

Crashes in the second category are harder to find. Since MuseScore application code uses abort() in various places, you need to look at the debug message, and then search through the source to locate the abort(). This bug calls for the removal of direct use of abort () to facilitate the use of the next option. This option is to place a breakpoint in the message handler (see below). To catch an abort caused by Q_ASSERT, trapping the message handler can be the only way to breakpoint before the crash, since the Q_ASSERT can come from within the Qt runtime and it may not be possible to use a breakpoint.

On Windows in more recent Qt versions, the Qt runtime abort () no longer activates the debugger, so the program just aborts without giving the developer the opportunity to inspect the call stack. Regarding this, we read in a Qt forum: If somewhere in the code a Q_ASSERT() evaluates false, the application is stopped with an info, where the Q_ASSERT() is and what expression evaluates false. If the application was run with a debugger, debugger is also stopped. If the developer wants to inspect a call stack, he must call qInstallMsgHandler() with a new MsgHandler, set a breakpoint in it and reproduce the bug.

Such a message handler already exists - it is located just before the main() function in mscore/mscore/musescore.cpp. Set your breakpoint where indicated in the code. The message handler is also useful, if you see debug output (printed via qDebug) and want to find out where it originates.

Git Workflow

The development of MuseScore uses GitHub to host the code and manage the collaboration of developers. GitHub is based on git, a popular SCM, initially designed and developed by Linus Torvalds for Linux kernel development.

If you're a developer who wants to work on the MuseScore source code and submit your changes to be merged into the main code, here's how. Thanks to Diaspora for their developer guide, which inspired this one.

Git references

Suggested workflow

If you don't have an account on GitHub, create one for free first. Also make sure you set up git on your computer. It's recommended to use SSH to access your own git fork.

This workflow is a command line workflow. If you prefer using a UI, GitHub also provides a UI tool for Mac and Windows, they can automate some of the following operations.

Summary

  1. Fork on GitHub (click Fork button)
  2. Clone to computer, use SSH URL ($ git clone git@github.com:you/MuseScore.git)
  3. Don't forget to cd into your repo: ($ cd MuseScore/)
  4. Set up remote upstream ($ git remote add upstream git://github.com/musescore/MuseScore.git)
  5. Set up the post-checkout hook (from build/git/hooks/, (see the README there)
  6. Create a branch for new issue ($ git checkout -b 404-new-feature)
  7. Develop on issue branch. [Time passes, the main MuseScore repository accumulates new commits]
  8. Commit changes to your local issue branch. ($ git add . ; git commit -m 'commit message')
  9. Fetch upstream ($ git fetch upstream)
  10. Update local master ($ git checkout master; git merge upstream/master)
  11. Rebase issue branch ($ git checkout 404-new-feature; git rebase master)
  12. Repeat steps 6-10 until dev is complete
  13. Push branch to GitHub ($ git push origin 404-new-feature)
  14. Start your browser, go to your Github repo, switch to "404-new-feature" branch and press the [Pull Request] button

After having made a Pull Request don't pull/merge anymore, it'll mess up the commit history. If you (have to) rebase, use 'push --force' ($ git push --force) to send it up to your GitHub repository, this will update the PR too. Be careful not to do this while the core team is working on merging in your PR.

Fork MuseScore repo to your own account

This will create a copy of MuseScore repository to your own account. To fork, press the fork button in the top right corner on MuseScore GitHub page.

Clone your GitHub fork to your computer

Run a clone command against your GitHub fork. It will look something like this, except that it will use your GitHub account name, instead of "you":

$ git clone git@github.com:you/MuseScore.git
$ cd MuseScore

This command downloads your copy of MuseScore to a git repository on your development machine. Change directory into the new MuseScore directory.
Set up the post-checkout hook (from build/git/hooks/, for details see the README there).

$ cp -p build/git/hooks/post-checkout .git/hooks/

To build MuseScore, you will need to install dependencies, and run the build process. Check the instructions for your platform in the developer handbook.

Note that the git clone command is using SSH in this case. You need to have SSH set up on your machine. A git:// URL would not work for your local fork, you will not be able to push on it. Alternatively you can use the HTTPS URL.

If you already cloned MuseScore main repository with

git clone git://github.com/musescore/MuseScore.git

You can change the remote url of the origin to your fork with

git remote set-url origin git@github.com:you/MuseScore.git

Choose something to work on

If you don't have a feature in mind, check out the issue tracker, or come ask in IRC (#musescore on freenode.net).

Create a Topical Development Branch

Before you start working on a new feature or bug fix, create a new branch in your local repository that's dedicated to that change. Name it by issue number (if applicable) and description. For example, if you're working on issue #78359, a slur layout problem, create a new branch called 78359-slurlayout, like this:

$ git checkout -b 78359-slurlayout

Write some code!

We are able to offer much help here :). If you can, provide some tests. See the mtest directory.
When you have got something working, commit the changes to your branch on your local Git repo. Firstly add the files you want to commit, and then commit. Don't forget to put a meaningful message. Use git status and git diff to see which files can be added and committed.

$ git status
$ git status <filename>
$ git add <filenames>
$ git commit -m 'fix #78359: Some kind of descriptive message' 

If your commit message starts with fix #xxxxx, with xxxx the issue number in the issue tracker, the issue will be marked as fixed automatically when your commit is pushed in the main repository

Keep your repo up to date with the main repo

In order to get the latest updates from the main repository, do a one-time setup to establish it as a remote by entering:

$ git remote add upstream git://github.com/musescore/MuseScore.git

The main repo will be now known as upstream. Your fork is known as origin. The origin remote is automatically created after cloning your GitHub fork to your computer.

To verify that you have two remotes, you can type:

$ git remote

Rebase your branch on the latest upstream

To keep your development branch up to date, rebase your changes on top of the current state of the upstream master.

# get the changes from upstream
$ git fetch upstream
# switch to your local master branch
$ git checkout master
$ git rebase upstream/master
# switch to your topical branch
$ git checkout 78359-slurlayout
#make sure all is committed as necessary in branch before rebasing
$ git rebase master

Rebase will put all your commits in the branch on hold, get the last changes, and apply your commits on top of it. You might need to resolve conflicts if you changed a file that has been changed in the main repo. To do so, edit the files, then git add them, and git commit.

Send your changes to MuseScore

When you are ready to send your modified code to MuseScore, push your branch in your origin remote.

$ git push origin 78359-slurlayout

Then do a pull request to MuseScore on GitHub. Go to your GitHub page, select the branch on the left, and press the Pull Request button at the top. Choose your branch, add a comment and submit your pull request. One of the developers with push rights on the main repo will merge your request ASAP. Important: If you haven't signed the MuseScore CLA yet, do this first as it's a requirement for your pull request to be accepted.
After having made a Pull Request don't pull/merge anymore, it'll mess up the commit history. If you (have to) rebase, use 'push --force' ($ git push --force) to send it up to your GitHub repository, this will update the PR too. Be careful not to do this while the core team is working on merging in your PR.

Advice & tips

Don't use git commit -a

$ git commit -a

This will perform git add for all unstaged files and commit. You probably don't want to do that. It's better to use git status and add files invidually before committing.

Delete a branch

To delete a local branch:

#will first check if the branch has been merged
$ git branch -d bugfix
#will delete the branch authoritatively
$ git branch -D bugfix

To delete a remote branch:

$ git push origin :newfeature

Create and apply a patch

It's better to contribute with a pull request than a patch but if you need to make a patch for any reason here is how.
You have created a local branch with the following command, made some changes and commit locally one or more times.

$ git checkout -b 404-new-feature

To create a patch against the master branch, run

git format-patch master --stdout >  404-new-feature.patch

To apply the resulting patch,

#get stats about the patch without applying it
$ git apply --stat 404-new-feature.patch
#check if the patch can be applied without problem
$ git apply --check 404-new-feature.patch
#apply the patch
$ git am --signoff < 404-new-feature.patch 

MuseScore Coding Rules

Note: This document is work in progress.

The coding rules aim to guide MuseScore developers in writing understandable and maintainable code, whilst minimizing confusion and surprise.

As usual, rules are not set in stone. If you have a good reason for breaking one, firstly, make sure that at least some other developers agree with you, especially if they are working on the same part of the codebase.

Submitting code

To submit code to MuseScore main repository, you need to sign the Contributor License Agreement. Your contribution can be a patch, or pull request, and should obey the following rules.

File format

  • All code is UTF8
  • Use UNIX linefeed

Coding Style

For historical reasons, MuseScore uses a special indenting scheme close to the Banner style. Take a closer look of the examples above to become familiar with it - particularly, the use of braces.

If you are using QtCreator, you can download and then import qt2-musescore.xml via Projects / Code Style / Import... to automate many of the behaviors described below.

Indentation & Whitespaces

  • Use six (6) spaces for indentation, no tabs.
  • Use blank lines to group statements together where suited.
  • Always use only one blank line.
  • Pointers and References

    For pointers or references, always use a single space after an asterisk (*) or an ampersand (&), but never before. Avoid C-style casts when possible:

    char* blockOfMemory = reinterpret_cast<char*>(malloc(data.size()));
    -NOT-
    char *blockOfMemory = (char *) malloc(data.size());
    

    Of course, in this particular case, using new is an even better option.

    Operator Names and Parentheses

    Do not use spaces between operator names and function names. The equation marks (==) are a part of the function name, and therefore, spaces make the declaration look like an expression:

    operator==(type)
    -NOT-
    operator == (type)
    
    Function Names and Parentheses

    Do not use spaces between function names and parentheses:

    void mangle()
    -NOT-
    void mangle ()
    
    Keywords

    Always use a single space after a keyword, and before a curly brace:

    if (foo) {
          }
    -NOT-
    if(foo){
          }
    

    Braces

    As a base rule, place the left curly brace on the same line as the start of the statement and indent the closing one. This is know as Banner style indentation.

    if (codec) {
          }
    -NOT-
    if (codec)
    {
    }
    

    Exception: Function implementations always have the left brace on a new line and indented. Class declarations don't.

    static void foo(int g)
          {
          qDebug("foo: %i", g);
          }
    
    class Moo {
          };
    

    Use curly braces when the body of a conditional statement contains more than one line, and also if a single line statement is somewhat complex. Otherwise, omit them:

    if (address.isEmpty())
          return false;
    for (int i = 0; i < 10; ++i)
          qDebug("%i", i);
    -NOT-
    if (address.isEmpty()) {
           return false;
           }
    for (int i = 0; i < 10; ++i) {
          qDebug("%i", i);
           }
    

    Exception 1: Use braces also if the parent statement covers several lines or if it wraps:

    if (address.isEmpty()
             || !isValid()
             || !codec) {
          return false;
          }
    

    Exception 2: Use braces also in if-then-else blocks where either the if-code or the else-code covers several lines:

    if (address.isEmpty()) {
        --it;
          } 
    else {
         qDebug("%s", qPrintable(address));
         ++it;
          }
    
     -NOT-
    
    if (address.isEmpty())
          --it;
    else {
          qDebug("%s", qPrintable(address));
         ++it;
          }
    
    if (a) {
          if (b)
               ...
          else
             ...
           }
    
     -NOT-
    
    if (a)
          if (b)
              ...
          else
             ...
    

    Use curly braces when the body of a conditional statement is empty:

    while (a) {}
    -NOT-
    while (a);
    

    Parentheses

    Use parentheses to group expressions:

    if ((a && b) || c)
    -NOT-
    if (a && b || c)
    
    (a + b) & c
    -NOT-
    a + b & c
    

    Names

    Naming conventions are similar to Qt.
    Names are of "camel" type, instead of "mops_klops" write "mopsKlops".
    User defined types are capitalized. Start the names of non-type entities with lowercase. Preprocessor defines are all uppercase.

    Do not encode type information in a name.

Fichier attachéTaille
qt2-musescore.xml1.93 Ko

References

Design & Implementation

There are only a few documents regarding MuseScore internals, except of course the code and its comments.

Element Classes hierarchy


Click on the image to download as PDF

Elements and Score objects model


Click on the image to download as PDF.

A score is represented by a Score object in memory. A Score object can have a parent Score if the score is an Excerpt. An Excerpt object is used to represent a part in part extraction. A Score also maintain a list of Excerpts if it has parts.

In a Score, notes are stored in a list of Measure object. Measure inherits from MeasureBase together with the frames. A Measure represents a measure across all the staff of a system, it's an "vertical column" of music. The Score also stores the tempo change list (TempoMap) and the time signature change list TimeSigMap. A Score object is complex, and has several states variables for layout, audio rendering. It also stored score metadata, style etc...

Layers in a Score object are a way to hide or show some Element according to the selected layer. A Score stores a list of Layers.

Layout

Element positions

The screen position of an visible element is computed from three values:

AP Anchor position of element. This is usually the position of the parent element.
LO Layout Offset, computed in the layout engine. MuseScore calculates it as the normal position of the element
UO User Offset, created by dragging an element by the user

The display position is computed as:
Display Position = AP + LO + UO

The saved position in a MuseScore file is computed as:
Saved Position = LO + UO

On read the saved position is written to the UserOffset (UO). The LayoutOffset (LO) is set to zero. On the first call of layout() the values for UO and LO are reconstructed. The condition LO==0 is used to determine the first call to layout().
After first Layout the values are computed as (RP = read position from file)

void Element::adjustReadPos()
            {
            if (RP != 0) {
		      UO = RP – newLO;
	            RP = 0;
		      }
            }

As a consequence, if you are writing an import filter and want to override the automatic placement of elements on import, set Element->_readPos. After layout MuseScore will compute a proper userOffset out of it.

Older MuseScore versions (<= 0.9.6) do only save the UO value. If loaded with a different MuseScore version than created, the position of certain elements may differ, as the layout algorithm (and the LO value) may have changed. This is avoided with the above scheme.

Caveats: adjustReadPos() has to be applied after the first complete layout of an element. This also means that a second layout() call should not change any element position. The layout has to be done in one pass.

Playback and synthesizers

msynth is a wrapper for Fluid & Aeolus
m-msynth is the mobile version, optimized and simplified
msynth2 is an experimental new synth version, not based on Fluid. Plan is to support SF2, SFZ and MuseScore own format.

Milestones

Basic notation

Ensemble

The previous version of MuseScore made significant strides towards preparing MuseScore for use on ensemble scores such as orchestra or band. Below are some remaining hurdles.

Lyrics

The following hurdles make MuseScore impractical or difficult for creating professional-quality scores with lyrics.

User Experience Enhancements

Version information

Release date and revision number for each stable version of MuseScore. The list matches the file version with the MuseScore version number used in the Help > About dialog.

MuseScore version mscx file version Release date Revision
Version 1.3 1.14 2012-02-27 r. 5702
Version 1.2 1.14 2012-03-13 r. 5470
Version 1.1 1.14 2011-07-27 r. 4611
Version 1.0 1.14 2011-02-07 r. 3996
Version 0.9.6.3 1.14 2010-09-25 r. 3507
Version 0.9.6.2 1.14 2010-08-16 r. 3400
Version 0.9.6.1 1.14 2010-07-13 r. 3280
Version 0.9.6 1.14 2010-06-07 r. 3145
Version 0.9.5 1.11 2009-08-14 r. 2012
Version 0.9.4 1.10 2009-03-21 r. 1518
Version 0.9.3 1.9 2008-09-21 r. 1102
Version 0.9.2 1.9 2008-04-12 r. 888
Version 0.9 1.4 2008-01-24 r. 646
Version 0.8 2007-12-19
Version 0.7 2007-09-15
Version 0.6.1 2007-07-30
Version 0.6 2007-07-24
Version 0.5 2007-03-29
Version 0.5 2007-03-29

Scrapbook of feature changes and additions

Purpose

As feature changes are made to MuseScore, they may be listed here. This will help developers in tracking work, help testers in using the nightly builds to try out new features and perhaps provide feedback, and perhaps most importantly, it will also help serve as a checklist of features needing documentation as MuseScore approaches a new release. The distinction between new feature and bug fix is sometimes blurry, but if a change will require documentation, it should probably be listed here.

Users should understand that features listed here may still be experimental and subject to further change or even removal.

Developers: Feel free to list new features here whether completely implemented or not. You may indicate any known limitations or bugs if you like, as well as any further enhancements you are considering. You may also wish to indicate whether users may provide feedback on the feature, and if so, whether you would prefer they do so via the issue tracker, the forums, the developers list, private email, or by other means. Provide as much or as little detail as you like. Even just listing a feature name with no additional information would be useful for the purpose of making sure it does not fall through the cracks when it comes time to create documentation.

Note: This page itself is experimental and subject to change in form and direction. A template for feature changes/additions is provided as a starting point, but if a different format is deemed more appropriate, feel free to use one and even to update the template if you feel this would make sense for others.

Changed / Added Features

Constrained dragging

  • Description: allows you to limit a given drag operation to horizontal or vertical movement only
  • Usage:: ctrl-drag to move elements horizontally; shift-drag to move them vertically
  • Known limitations/bugs/opportunities: element is first reset to original/default position
  • Feedback desired:

Notes: See http://musescore.org/en/node/9346

More flexible clef changes

Rev. 4080 implements more flexible clef changes. Example is a piano score were the top staff starts with a G clef and switches immediately to an F clef.
clefchange.png

Drag/Drop elements on score view

Elements on the score view can be used like palette elements. For this press Shift+Ctrl and drag an element with left mouse button.
This also allows to drop elements from the score view to a palette. (First you have to make the palette changable, see palette context menu).

Continued Drop

If you press Shift+Ctrl and drag an element from the palette, the operation does not end on drop. You can can continue to drop to other locations. This is currently not implemented for all kind of elements. Tested with articulations.

Enhanced Clef Layout

Clef layout spacing was changed in revision 4101. In previous versions clefs looked like:
clef-layout2.png or clef-layout3.png
This is the new spacing:
clef-layout1.png and clef-layout4.png
The changes may have side effects and need testing.

Local Time Signatures

Time signatures can be different for different staves. An example here is Bachs 26. Goldberg Variation:

gb26-1.png

MuseScore has the concept of a global time signature and an actual (local) time signature. You change the global time signature by drag&drop a palette object to a staff. The global time signature is used to count beats (as shown in the status line) and is the reference for tempo markings. The global time signature is the same for all staves and normally identical to the actual time signature.

The actual time signature is set in the time signature property dialog and can deviate from the global time signature for every staff (left hand 18/16 in the example)

gb26-2.png

The text of the time signature can be set independent of the actual values.

A local time signature is set by dropping a time signature symbol with the Ctrl key pressed. The local time signature is set only for one staff. A global time signature is replicated for all staves.

Album Manager

The album manager allows to prepare a list of scores. The list can then be saved as an album file ("*.album").

album.png

The first implemented action for an album is "Print". The album scores are printed in order with the correct page numbers set overriding the page number offset values in "Page Style". The album is printed in one print job so double sided printing (duplex printing) also works as expected.

Layers

For the Open-Goldberg project i want to be able to create different versions of the score. One version is the "Urtext", a score which is close to the original version of Bach. A second version could be a Czerny variation, which in addition to the Urtext contains fingerings.

The layer feature allows to create different versions out of one score file. If you want to add fingerings you have to create a layer and tag the fingering elements with the layer name.

First create layers:

layer1.png

Second create a score variant:

layer2.png

Add the visible layer to the score variant. Then select all fingerings and tag them with the name of the score variant:

layer3.png

Default layer:
layer4.png

Czerny layer:
layer5.png

Metronome

  • Description: You can switch on and off a metronome during playback and the cursor now move beat by beat. It's a new button in the toolbar.
  • Usage: If you use MuseScore as a repeater, you now have a metronome
  • Feature request: #4199: Metronome on playback

Follow and unfollow the score during playback

  • Description: You can switch the following of the score on and off during playback. It's new button in the toolbar
  • Usage: It's now possible to listen to a measure while scrolling around the score.
  • Feature request: #12331: Option to not pan the score while playing

Local Relayout

Notes and Rests at the same time position are vertically aligned by default. Sometimes this is not desired.
A new feature allows to relayout beamed notes and rest without considering notes/rests in other staves.

Before setting relayout flag:
relayout1.png
Checking relayout flag:
relayout2.png
After setting relayout flag
relayout3.png

Other examples: http://musescore.org/en/node/18826#comment-68687

Programmable MIDI actions

  • Description: When you are entering notes with a MIDI keyboard, you need to go back to your computer keyboard to play, or change the notes duration. Now you can program some keys on your MIDI keyboard to do these actions.
  • Usage: Go to Preferences -> Note Entry to program MIDI actions.
  • Known limitations/bugs/opportunities: None. Please report in the issue tracker.
  • Feedback desired: Yes

New audio architecture: SF3, Aeolus, Zerberus, effects

  • Description: A new audio architecture for synthesizer and effects.
  • Read more about it
  • Feedback welcome

Repitch mode

  • A simple way to change pitches of a passage without affecting the rhythm, ornaments, slurs etc...
  • Read more about it
  • Feedback welcome

Extended Ties

tie1.png is rendered as tie2.png

WYTIWYG chord symbols

  • Description: you can now type chords however you like, and they will be understood and rendered as well as possible. So you can type Bbm7, Bbmi7, Bbmin7, or Bb-7 and they are all understood as minor seventh chords and rendered well. A "Standard" and "Jazz" rendering style are provided and will render similarly to the old "stdchords.xml" and "cchords_muse.xml" in terms of fonts, superscrpting, etc, but both styles support this WYTIWYG mode so you can always use whatever abbreviations you like, use parentheses around alterations or not, etc. In addition, you can enter parentheses around chords to show they are optional, and they will still be handled correctly. Otherwise unparseable entries like "N.C." or "/" are also rendered consistently with other chords.
  • Usage: Chords are entered just as before; you just don't have to be so careful about how you spell them
  • Known limitations/bugs/opportunities: As long as the root is recognizeable, the chord will render and transpose reasonable. So Bbrandom will transpose as Crandom, etc. But MusicXML export only works to the extent the chord is actually understandable according to a predetermined list of acceptable abbreviations for major, minor, etc. Eventually we could allow this list itself to be customizable if there is felt to be sufficient need.
  • Feedback desired: Any. Most interesting: are the examples of chord symbols that can be found in published literature that are *not* handled correctly?

Notes: this is how a variety of different chord symbols will render in the "Jazz" style:
wysiwyg_chords.png

International chord symbols

  • Description: adds options for Solfeggio and Lower case minor chords, improves German chord mode
  • Usage:: Style / General / Chordname, select from radio buttons for Standard, German, Solfeggio root naming, checkbox for Lower case minor chords. Existing chords are automatically converted to selected style, and new chord entry respects these settings, so typing Do7 in Solfeggio mode results in a C (Do) dominant seventh chord rather than a D diminished, and typing "a7" in Standard mode with "Lower case minor chords" enabled is understood as a minor seventh chord rather than a dominant seventh.
  • Known limitations/bugs/opportunities: further customizations (such as rendering "Re" with an accent on the "e") are possible by editing the chord description file.
  • Feedback desired: Did we get the most important case, and are they handled correctly? Specifics were taken from LilyPond for the most part. For instance, in German mode, chords are now rendered with accidentals as "is" and "es" rather than sharp and flat; bass notes always lower case regardless of major/minor. In Standard or Solfeggio modes, with "Lower case minor chords" checked, bass notes remain upper case. In Solfeggio mode, we use "Do", "Sol" and "Si" rather than "Ut", "So", or "Ti". Are any of these decisions contrary to what most people using these options would expect?

Notes:

Count-in

  • Description: You can switch on and off a count-in to be played each time the playback starts. The count-in plays beats for a full measure (according to nominal time signature at playback starting point); if the starting point is mid-measure or at a 'short' measure (anacrusis), it also plays enough beats to fill the measure missing part. User interface: a button in the Play Panel.
  • Usage: If you use MuseScore as a MinusOne repeater, you can sync your 'entrée' with MuseScore's.

(Feature name)

  • Description:
  • Usage:
  • Known limitations/bugs/opportunities:
  • Feedback desired:

Notes:

Development infrastructure

MuseScore source code is hosted on GitHub.

Automated nightly builds

The nightly builds aren't so much "nightly" anymore. The Zurich University of the Arts kindly hosts two virtual machines running Windows 7 and Mac OS X 10.7. These two computers are polling the master branch of the Git repository every hour for Windows and every 20 minutes for Mac OS X - if a new revision is found, a nightly build will be packaged. The packages for Mac and Windows are uploaded via FTP on http://prereleases.musescore.org. This server is currently a cheap shared hosting server with unlimited bandwidth. It also runs an HTTP server with PHP to present the files. Only the last 20 nightlies per OS are kept there.

The Mac OS X build server also run a IRC bot. It notifies the #musescore IRC channel when a new build for Mac is available, or if it has failed.

Continuous integration using Travis-CI

For every code pushed, GitHub sends a notification to Travis-CI.org, a free hosted continuous integration service for the open source community. Travis uses the file .travis.yml at the root of the source code tree to build MuseScore, and run the unit tests located in the mtests directory.
If the build or the tests fail, Travis will notify the #musescore channel on IRC, and send emails to committers.

Mark issue as fixed automatically

GitHub can send a POST HTTP requests to any URL. MuseScore.org uses this feature to receive notification of every new commit on the master branch of the Git repository. If the commit message starts with "fix #xxxxx", with xxxxx the issue number in the issue tracker, the issue will be marked as fixed automatically.

Git Push notification on IRC

GitHub sends a notification on the #musescore IRC channel for each new push on the Git repository.


Source https://docs.google.com/drawings/d/1nYccYxrTQsHYnxELcHCbnHzLXiJyccs9g1BG...

MuseScore 2.0 Roadmap

This is a list of what we wish to achieve for MuseScore 2.0. It is ideal for testing features in the nightly builds, particularly if they are deemed stable enough by developers. These are also subject to change.

Palettes

Custom palettes operations are described in detail in this forum post

  • Add, move and delete a palette Done, ready for testing
  • Add, move and delete elements Done, ready for testing
  • Add SVG, PNG, JPG to palette Done, ready for testing
  • Master Palette (Display -> Master Palette) to pick default elements Done, ready for testing
  • Palettes shoud be saved on exit and become available upon program start Done, ready for testing
  • Export/import all the palettes = profile. Use case: palettes for piano score, orchestral scores
    Done (move profile files from/to the MuseScore profiles folder)
  • Export/import single palette. Use case: palette for handbells, palette for autoharp, etc... Done, ready for testing

Open Questions

  • How to handle resize, scaling: spatium unit (usability question)

Known Issues

Issues tagged with palette

Time Signature, Corner Cases

  • Spanner at start or end
  • Time signature code could be used to copy/paste

Known Issues

Issues tagged with time signature

Linked Parts

Linked parts in one score are more or less the same as extracted parts, so testing one is also testing the others.

  • Regression tests are needed
  • Delete/Insert Measures DONE, ready for testing
  • Feature missing: Ability to choose elements that will not be synchronised
  • Feature missing: Add style for parts in Parts window, it’s already a preference

Tablature

  • Staff configuration DONE, ready for testing Discussion
  • Better note entry, specific shortcuts mostly DONE, ready for testing Discussion
  • MusicXML in/out ??

Figured Bass

  • Add, delete: DONE, ready for testing (preliminary instructions)
  • Proper alignment and combined shapes: DONE, ready for testing
  • Configuration: DONE, ready for testing
  • Durations: DONE, ready for testing
  • Continuation line formatting: DONE, ready for testing
  • MusicXML in/out: Done?

Fret Diagrams

  • Possibility to combine them with chordnames
  • Add automatic fret diagram generation according to chordname, need chord spellings
  • Automatic spacing vertically of diagram/chord names
  • Future features: playback, voicing
  • Example: http://www.qwikchord.com/portal/

Remarks

Requires expert help - someone who knows chordnames very well + guitarist for chord spelling and voicing

Frame For Chord Names/Fretboard Index

  • Currently exists as a new type of frame
  • Needs to be populated, chordnames sorted by order of appearance in the score TODO
  • Ability to have one by section and chord collection should stop at section break TODO

Inspector

  • Needs a better name
  • Only implemented for some elements, need to finish the implementation
  • Selecting several elements is possible
  • Nice way to move z index of an image
  • Nice way to align several elements
  • Based on properties, QVariant with default, setter and getter, a name and an ID.
    • Properties should be used in Plugin Framework
    • Properties are used in Undo and Redo list
    • XML serialization is using properties name

Playback in sync with audio file

The goal here is to be able to play an actual audio file in sync with the score. An audio player needs to be added in MuseScore and an interface to map the audio with the score. The MuseScore file format will be modified to embed the audio file, like it does currently with images.

  • Modified file format
  • Add a vorbis player in MuseScore Done
  • User interface for adding additional media (e.g. ogg vorbis file) Done
  • User interface for selecting the play mode (play synthesizer, play audio track) Done
  • User interface to create special tempo map to sync audio with score

Scroll View

A scroll view to edit more easily scores currently with multiple system per page is a popular request: #5982: Add a continuous (scrolling) mode view

Barlines

Quarter Tone Accidentals

  • Playback should be a style (accidental -> X semitones)
  • Support for key signature
  • MIDI export with bend != Fluid export (microtune synth)

Line

  • Unified UI - users want only one line dialog, even for a tremolo line, more line styleTODO

Playback

  • Real instrument change
  • Improve instrument description in instruments.xml (sysex, articulations...)
  • Add a element to change instrument
  • No panic button, bug is fixed

Instruments.xml → split in two files

  • One file is the base, all instruments, language independent
  • One file, language dependent, can add instruments

Chord articulations

Description?

Instrument Editor

See New Cascading Instrument Definition
Currently, the way to add/edit instruments requires you to edit the instruments.xml file. A user interface for this would be great.

Virtual Keyboard

  • Animate keys during playback

Virtual Guitar Neck

Copy/Paste

Plugin Framework

Use properties

Redesign, Style Engine

  • Toolbar icon set: technical info on how to design and test the toolbar

Documentation

Things we'd like to see improved:

  • Don't package MuseScore with all the localized handbooks in PDF format
  • Offer build in view of the handbook in MuseScore
  • Offer a TOC
  • Ability to search through the handbook
  • An index (glossary)
  • The handbook PDF file is not updated regular enough

Solution:

  • Replace the packaged PDF with HTML: this reduces the size by a third, because fonts do not need to be embedded
  • When rewriting the handbook 2.0, decide on markup to compile TOC and glossary index
  • Pull in the handbook from the internet, instead of shipping it with the MuseScore package
  • Create service to compile the PDF from the online handbook at regular times and offer the PDF download
  • Create search facility in MuseScore to search through the handbook

Open issues which needs to be addressed in the meantime:
#16792: Most links to video tutorials in the PDF handbooks don't work
#8140: Documentation: Glossary vs. Snippets
#17994: Offer permalinks for titles in the handbook

Translation

Problems with the current translation system.

MuseScore

The translation server for MuseScore is located at http://translate.musescore.org. This solution is lacking many features, especially on community features, such as emailing contributors when new translations have been submitted. There is a huge maintenance/development cost in running and maintaining this server. The best solution would be to move towards a hosted solution, such as Transifex.

MuseScore.org

When the English source page is updated, translators should be able to get email notification together with direct links to know what has changed and to be able to reflect these on their page.
Handbook pages containing outdated translations should mention a warning to the visitor that the content of the page may have since been updated. For a more updated version, check out the English one, or help (linked) to update the current translation. This can all be implemented on musescore.org itself, therefore it not being required to seek a hosted solution.

Video tutorials

Captions of the Getting Started video tutorials are being translated on musescore.org. It works well, but a problem is that new, or updated caption translations are not automatically uploaded to YouTube via API. As there is no PHP library available yet, we could either use a different language available on a Linux machine, or we seek a hosted solution.

Release Notes

Release notes for MuseScore 0.9.6.1

MuseScore 0.9.6.1 is mainly a bugfix release including almost 40 bugfixes. There are no new features in 0.9.6.1 compared to 0.9.6. You can read the details of the bugfixes below.

Crashes and critical

  • fix #6425: Crash loading score with breath mark selected
  • fix #6388: Crash on importing a MusicXML file (beam problem)
  • fix #6072: Crash when adding note to wrong percussion staff
  • fix #6335: Crash on creating triplet on a chord
  • fix #6289: crash on loading score where a key signature is selected
  • fix #6275: Remove the last inserted vertical frame make musecore hangs
  • fix #6138: crash on creating new score (after some steps)
  • fix #6076: crash on play a new score after exiting a playing score
  • fix #6049: 0.9.5 file with breve or longa cannot be opened with MuseScore 0.9.6

Memory management

  • fix #6164: free memory after removing score

Sound

  • fix #5162: Artefacts in "Strings CLP" sound
  • fix #6093: Dynamics are not played for Soprano in TimGM6mb.sf2
  • fix #6253: High CPU usage when idle if reverb is on

Import & export

  • fix #6318: MusicXML export of syllabic is broken
  • fix #5949: MIDI import gives unexpectedly silent notes
  • fix #6163: Export MIDI in wrong preference tab
  • fix #6283: R key does not work as expected in drum staff

Transpose

  • fix #6254: Concert pitch lossy transposition
  • fix #6264: Chordnames not transposed on copy-paste or concert pitch
  • fix #5923: Transpose chordnames does not preserve pitch spelling

Handbook

  • fix #6060: Help > Local Handbook doesn't work on windows
  • fix #6060: Change pdf filenames for composed locale handbook

Miscellaneous fixes

  • fix dragging from palette of measure repeat symbol
  • remove incompatible "temperament tuning" plugin
  • fix adding notes on voice > 0 from plugin framework
  • fix ove import charset preferences init
  • fix layout of fermata if in staff > 1
  • fix #6245: Underscores in Lyrics are not copied badly/not at all
  • fix #5906: Tick value shown in Object Inspector limited to 999999
  • fix #5903: Duration arithmentic with longa and brevis
  • fix #6195: breve rest & longa rest are inversed
  • fix #6079: problem in multimeasure rests with 2 staves score
  • fix #6172: note properties does not keep notehead group
  • fix #6144: Notes (and other signs) in small staves are smaller than they should
  • fix #6134: Fingering text offset does not save units and alignment
  • fix #6114: SVG graphics disappear after reload
  • fix #6453: File containing a horizontal frame directly before a bar with a line break cannot be opened
  • no empty tab if user tries to open a file with unknown extension
  • page numbers are no longer editable in the score since formatting does not stick
  • refuse to open incompatible score files (file version number > current version number); this adds new translatable strings

Translation

  • updated translations
  • new translations : Basque, Hebrew, Slovenian

Release notes for MuseScore 0.9.6.2

MuseScore 0.9.6.2 is a bugfix release including 12 bugfixes mainly critical ones. There are no new features in 0.9.6.2 compared to 0.9.6. You can read the details of the bugfixes below.

Critical

  • fix #6597: Close/reload crash on XP
  • fix #6658: Natural in every keysig on mac PPC
  • fix #6508: Crash removing instrument with volta
  • fix #6706: Crash when inserting slurs from palette while editing text
  • fix #6740: Autosave works only the first time
  • fix #6479: Crash when closing score during playback
  • fix #6624: Crash when deleting a tuplet from a MusicXML import
  • fix #5667: Font problem (quarternote looks too big in text on Linux)
  • fix #6620 : Crash on changing dynamics font size
    • Plugin framework

      • fix cursor move on repeatmeasure in plugin framework
      • fix instrument name containing flats for plugin framework

      UI

      • fix #6505: Mixer is not refreshed when scores are switched
      • fix mouse wheel handling for mixer elements
      • fix repeat command (ctrl+r) for staves > 1

      Translation

Release notes for MuseScore 0.9.6.3

MuseScore 0.9.6.3 is a bug-fix release that corrects more than 13 problems, mostly critical. There are no new features in 0.9.6.3 compared to 0.9.6. Below is a full list of the corrections.

  • fix #6775: Seg. fault by double clicking any element twice
  • fix #7233: Transpose by diminished second doesn't work (0.9.6 branch regression)
  • fix #7232: D.S. after coda sign freezes playback
  • fix #7167: Time signature change causes triplets to corrupt score
  • fix #7211: Copy/Paste notes over rest of diff. durations in staves
  • fix #7142: Crescendo & delete measures problems
  • fix #7197: MuseScore fails to open MSCZ files with capitals
  • fix #6932: Changing notehead of a breve crash
  • fix #7077: Applying double-note tremolo to dotted notes fails and alter measure duration
  • fix #6937: Measure Properties should be modal dialog
  • fix #6888: When exchanging voice, voice 1 is removed
  • fix get keysig from plugin when concert pitch mode is set
  • fix #6735: C# for AltoSax in default soundfont is silent
  • add access to DPI and notehead, note boundingbox and note position from plugin framework
  • fix #7150: Changing soundfont does not work for audio export

Documentation

  • New handbook for Danish

Translation

Release notes for MuseScore 1.0

MuseScore 1.0 builds further on the foundation of MuseScore 0.9.6 and the 3 bug fix releases released since June 2010. The focus of this release was stability by reducing bugs, only a very limited set of new features were added. Several new translations were added.

Important information for people upgrading

  • The keyboard shortcut for rests during note entry changed from Space to 0 (Zero). In MuseScore 1.0 Space now starts playback similar to most other media software. If you prefer the old shortcuts you can change them as explained in the handbook (see keyboard shortcuts)
  • Changing instrument names in front of staves involves an extra step. In previous versions you could double click on the instrument name and edit it directly. Unfortunately this method sometimes caused crashes or corruption and is disabled for MuseScore 1.0. However you can still edit the instrument names. Right-click on an empty part of a measure for the staff you want to rename and choose "Staff Properties..." from the context menu. In the Staff Properties dialog you can change the "Long instrument name" which appears on the first system or the "Short instrument name" which appears on subsequent systems.

New features

  • Ability to hide courtesy key signature and canceling naturals. See #8357.
  • Ability to choose first page number. See #8356.
  • Bagpipe Music Writer import and bagpipe sound support. See #8355.
  • Ability to change velocity and on/off offsets for a group of selected notes

MuseScore.com

  • New workflow for Save online plugin
  • Ability to sign out
  • Option to automatically sign out on exit

MusicXML

  • improve MusicXML import of clefs
  • fix #8498: musicxml import/export: print-object="no" not handled for key signature
  • fix #8435: musicxml import: print-object="no" ignored on rest
  • fix #8474: MusicXML import: Audiveris ".0" not handled in alter and in backup and forward duration
  • fix #8428: musicxml import: voices mixed up
  • fix #4858: Courtesy accidentals do not import/export in MusicXML anymore
  • fix #8400: musicxml export: stem on whole note in triplet
  • fix #8546: MusicXML import: dynamics in notations element are ignored

Usability and interface

  • fix #8503: Space for play/pause and 0 (Zero) for rest input
  • add SVG icons for note entry toolbar
  • change toolbar icon default size
  • fix default "Save as" and "Save copy" directory
  • display palettes on first start
  • Adding panning to templates
  • enable time signature deletion in timesig palette
  • fixed vocal range for bartione and bass (instruments.xml)
  • fix #6345: First time users confuse demo score for demo software
  • fix: Local Handbook disabled when no file is open

Audio

  • Adding panning to templates
  • fix #7857: Tics in generated wave files

Mac specific

  • fix #6547: File association on Mac. Add bww, cap, sgu, mgu, mid, ove, md, and MusicXML.

Bug fixes

  • fix #9040: Dragging note horizontally removes accidental permanently
  • fix #8974: Rest entry shortcut does not work in Voice 2
  • fix #9002: Reset Position doesn't affect tuplet bracket
  • fix #4975: Parts should have multi-measure rests by default
  • fix #8865: Crash when changing instrument on drumstaff
  • fix #8842: bracketed accidentals not saved)
  • fix #8727: write accidentals with parentheses
  • fix #8763: Tuplet number not spatium dependent
  • fix #8735: Beat corruption in copy paste of partial measure
  • fix #8750: Crashes with system containing only vertical box
  • fix #6736: Preferences Menu disabled in non english. Avoid merging of menus.
  • fix #8719: Pickup measure messes up Lilypond export
  • fix #3092: Cannot see 16th note (and below) ledger lines
  • fix #6317: Ledger lines not long enough for whole notes
  • fix #8613: MuseScore doesn't ask to restore session if you open from file
  • fix #8612: Cannot paste to measure with a grace note before beat 1
  • fix #7303: Collision between rest and accidentals
  • fix #6599: Command line option to change config/settings directory
  • fix #6362: Tempo text position not saved for part > 1
  • fix #6347: Multiple grace notes do not copy correctly
  • fix #7764: crashes when open ove file
  • fix #8372: Fix to end-start-repeat bar line width
  • fix #8369: Delete one instrument removes slurs from others
  • fix #8358: new score: create one measure more when pickup measure selected
  • fix #8347: tie in note entry does not work for voice > 1 after a barline
  • fix #8308: Creating triplet in grace note leads to time corruption
  • fix #6536: Position of stemslash in grace note chord
  • fix #7415: Stems too short for 32nd and 64th notes
  • fix #8273: Unecessary courtesy clef remains when clef is changed
  • fix #8194: Edit instruments mess up instrument name
  • fix #8184: Creating parts with cross staff barlines crash
  • fix #8161: Missing lyrics in MIDI import
  • fix #8018: Lilypond: Quote marks in lyrics need to be escaped
  • fix #7892: Exchange voices adds extra rests
  • fix #7944: Buffer overflow with a lot of instruments
  • fix #7017: Chord names does not support "H" name as chord
  • fix #7249: Notehead should be on top of the staff lines
  • fix #7311: Dragging tied notes and removing tie gives weird result
  • fix #7882: Transposing a score shouldn't transpose a drum staff
  • fix #6320: Add œ in F2 text palette
  • fix #7881: Exchange voices does not work on last measure
  • fix #7832: Extra spaces cause lyric pasting to repeat words
  • fix #7734: Pasting lyrics with spaces is not working
  • fix #6451: score jump to current position when record MIDI in Note Input Mode
  • fix #7614: menu item crash when continuing session with no scores
  • Better voltas + multimeasure rest layout
  • fix default fingering font
  • fix #7665: Change instrument, undo does not undo sound
  • fix #7624: pressing space bar when slur is selected crashes program
  • fix #7562: Cursor in text remains in print or PDF
  • fix #7530: Hairpin starting on the first note is lost on reload
  • fix #7514: Moving instrument deletes tuplets
  • fix #7520: Undo reorder instruments does not work as expected
  • fix #7519: Moving instrument causes crash
  • fix #7740: drag and delete + undo causes crash
  • fix #7315: limit values in time signature wizard to 6 bit (1-63)
  • fix #6649: Transposition when creating a score from a template

Translation

Credits

Programming

  • Werner Schweer: Project lead, main developer
  • Nicolas Froment (lasconic): Windows and Mac OS builds, bug fixes
  • Toby Smithe: Debian and Ubuntu builds
  • Olav Gundersen: LilyPond export developer
  • Leon Vinken: MusicXML import-export developer, BWW import
  • Rui Fan: Ove import
  • Maurizio M. Gavioli (Miwarre): new features patches
  • Friedemann Becker: bug fixes

Localization

  • Afrikaans
    • djboer
  • Arabic
    • Hosam Adeeb Nashed
  • Asturian
    • Arcipiecu
  • Basque
    • lgerenu
    • amenudo
  • Catalan
    • Carles Clavero
  • Chinese, Traditional
    • hishine
    • aeolus
    • Curtis Huang
    • yushengc
    • vixensjlin
    • Edward Liao
    • 陳科旭
    • yanganto
    • kagami3421
    • millieyun
  • Chinese, Traditional (Taiwan)
    • benice
    • yingdat
    • aeolus
    • nwhat
  • Chinese, Simplified
    • Rui Fan
    • smithtao
    • weyllor
    • oldherl
    • 李百平
    • punbit
    • LianZhang
    • hishine
  • Czech
    • pfri
    • mkucera66
    • Peregrinus
  • Danish
    • Morten Poulsen
    • Stig Wolff
  • Dutch
    • Jaap Plaisier
    • Thomas Bonte
    • toeter
    • Richard Pasveer
    • Legov
    • mouk
    • Antiklontermiddel
  • English, US
    • Raymond May Jr.
    • ceegers
  • Finnish
    • Heino Keränen
    • hjunes
  • French
    • Jean-Louis Waltener
    • Nicolas Froment (lasconic)
    • ritmus
    • utopie
    • Billard Sirakawa
    • Tchoun
    • Robert Leleu
  • Galician
    • Xosé
  • German
    • Werner Schweer
    • derhannes
    • fnbecker
    • Jojo-Schmitz
    • pianopleasure
    • sheksel
    • chrisch
  • Greek
    • Panagiotis Vlangopoulos, Assistant Professor of the Music Department of the Ionian University
    • Ioannis Toulis, Assistant Professor of the Music Department of the Ionian University
    • Petros Andriotis, Adjunct Teacher of the Music Department of the Ionian University
    • Niki Stavrati, Master Degree Student of the Music Department of the Ionian University
    • Loukas Ksanthos
  • Hindi
    • Shashi Sharma
  • Hungarian
    • molnarm
    • drikanb
    • thSoft
  • Indonesian
    • agatorex
    • gilang.pratama
    • tedibudiwan
  • Italian
    • Angelo Contardi
    • Antonio Marchionne
    • Daniele Bravi
  • Japanese
    • Neco
    • kiki
    • kimikazu
    • kojikoji
  • Korean
    • JongHo Kim
  • Norwegian
    • Dag Henning Sørbø
    • Per Holje
  • Polish
    • Piotr Komorowski
  • Portuguese, Brazilian
    • israel_zeu
    • Vítor Dassie
    • marlonpimentel
  • Portuguese
    • José Luciano Batista Gomes
    • elchano
    • tiago
    • marlonpimentel
    • rmatosinhos
    • ariconstancio
    • ganglia
  • Romanian
    • Claudius Tiberiu Iacob
  • Russian
    • Alexandre Prokoudine
    • kostiagol
  • Slovenian
    • ThePianoGuy
  • Spanish
    • Carlos Sanchiavedraz
    • Juan Díaz Porras (alkayata)
    • Pascual Marchante Lande (Mitocondria)
    • MrTrebleClef
    • chiqui5256
    • pup
    • Axel
  • Swedish
    • Magnus Johansson
    • Stefan Falt
    • mbockert
    • dalahast
  • Thai
    • punbit
  • Turkish
    • Halil Kirazli
  • Ukrainian
    • Serhij Dubyk

Other

  • David Bolton: Handbook
  • Thomas Bonte: Website
  • Katie Wardrobe: Video tutorials
  • Tim Brechbill: SoundFont
  • Han-Wen Nienhuys, Jan Nieuwenhuizen & others: Emmentaler font
  • Raùl Posac: MuseScore logo
  • Zachary Chione: Splash screen design

Release notes for MuseScore 1.1

MuseScore 1.1 is a bug fix release. The focus of this release was stability by reducing bugs, only a very limited set of new features were added. Several new translations were added.

New Features

  • MuseScore Connect
  • add sol notehead, alternative brevist notehead group, new symbols for old notation
  • fix #4526: Adding ties to chords
  • MuseJazz font includes triangle, circle with a slash, and other symbols for chords
  • MuseJazz font includes complete ASCII character set for text
  • New "MuseJazz" style to use MuseJazz for all text elements
  • New "Jazz Lead Sheet" template and style
  • New chord description (XML) files to switch between popular styles of chord symbols
  • Space / Shift-Space in chordname entry allows chords to be placed on beats with no notes
  • Tab / Shift-Tab in chordname entry skips to the next / previous measure
  • "Acoustic Bass" (pizz. default) added to instrument list

Bug fixes

Import/export

  • fix printing of images (fix #10140: Save as PDF with several images causes crash)
  • fix #11245: MusicXML doesn't save Tempo Text if there's no name
  • fix crash on capella import with timesig 0
  • import part name from MusicXML
  • Add support for notehead color in MusicXML export and import
  • Add shape notehead support in MusicXML export and import
  • add MusicXML testfile for noteheads
  • import & export harmony even if not on chord/rest in MusicXML
  • fix #10849: musicxml exports lyrics only with notes in voice 1.
    note: file attached to http://musescore.org/en/node/10168 not handled yet
  • fix crash on WAV export in fluid
  • fix #9919: error on open/read musicxml was not handled
  • fix #9842: Tempo value not exported in Lilypond
  • fix #9830: Percussion sounds not exported correctly in MusicXML

Playback

  • reduce default reverb gain from 0.5 to 0.2
  • fix #11164: Synth control status on startup and audio export
  • fix #5142: Notes do not release together in Swing or Shuffle mode
  • fix playback start position when repeat in the score
  • fallback to default soundfont if can't load the preferences one

Usability and interface

  • open MuseScore maximize on very first startup
  • fix entry of underline character in lyrics entry mode
    (for german keyboard press Strg+Umsch+"-", for english Ctrl+"_")
  • better handling of Tab key in text element
  • fix #11246: change default number of measures and pickup measure timesig
  • Restore ability to delete instrument name in place
  • Right click on instrument name for staff properties
  • new chordstyle is apply now immediatly
  • remove "what's this" in toolbar and help menu
  • remove delete button in symboldialog, fix system flag
  • fix #10935: fix Soundfont path //
  • fix #10934: double error message on opening a 2.0 score
  • add shortcut for navigating between score tab

Plugins

  • add timesig object in plugin framework
  • add undo support for scnote pitch and tuning
  • add : chord.small, chord.noStem, rest.small, note.velocity, score.keysig, score.timesig
  • set notehead shape from plugin framework
  • more page format option accessible via plugins

Build

  • fix #10915: Rename WRC to WRC.BAT in CMakeList.txt

Miscellaneous

  • fix #11267: Shift + drag tuplet, delete, undo cause crash
  • fix #10585: Accidental offset in small staves corrupted by saving and reloading (patch by Miwarre)
  • fix #10313: Align settings in Edit Text Style dlg box not stored (patch by Miwarre)
  • fix rest position for 1 and 3 staff lines
  • don't play midi note according to preferences (#10024)
  • measure number no more selectable to avoid crash on undo
  • barline at start of system not selectable to avoid crash on undo
  • can't create empty part anymore
  • fix #10564: Selecting voice before enabling Note Entry and entering notes causes crash
  • fix #9107: Pasting multiple multi-voice notes causes crash
  • fix #9805: Second Voice can end up broken
  • fix #9307: Nested tuplets causes crash
  • fix crash reported in http://musescore.org/node/10674 comment 2
  • fix #1722: Continue last session tries to open discarded score
  • fix #9338: chordname scrolls offscreen
  • fix #10660: Continue last session & play panel enabled
  • fix #5900: Courtesy accidentals lost in transposition
  • fix #9332: Unable to create slash-headed notes on drum staff
  • fix #10165: Measure num. every n shows number (every n) + 1
  • fix #9342: repeat entry doesn't scroll display
  • fix #10048: Opening Page Settings causes crash
  • fix #10370: Shortcuts cannot be cleared, implement "reset to defaults" in preferences-shortcuts dialog
  • fix #10335: importCharsetList does not appear
  • fix #10264: Select a flag and enter a note causes crash
  • fix #7814: error with single-line-staff percussion notation
  • don't print blue frame around selected image
  • fix #7944: Instrument limit (again)
  • fix #9996: Chord navigation does not work on multistaff
  • fix #9883: Insert vertical frame between two parts of the same line (volta, cresc) causes crash
  • fix #9852: Measure number hidden by horizontal frame
  • fix #9792: Clef not displayed after changing clefs in previous measures
  • fix #9790: Pasting notes featuring key signature change and lyrics corrupts following bar
  • fix crash when inserting vertical frame (#9765)

Translation

  • New languages: Faeroese, Slovak, Lithuanian, Croatian, Belarusian, Vietnamese, Esperanto, Persian
  • All existing languages are updated from http://translate.musescore.org

Release notes for MuseScore 1.2

The focus of MuseScore 1.2 is stability, by reducing bugs. Only a very limited set of new features have been added. Translations and the handbooks have been updated. Estonian and Belarusian have been added.
MuseScore Connect has been updated.

New Features

  • New demo score: Reunion by Marc Sabatella
  • MuseJazz now includes diacritical characters (Thanks to Marc Sabatella and Jorg K)
  • Jazz Combo and Band templates by Marc Sabatella
  • Save absolute position of element in addition to "offset" for better upward compatibility with 2.0 version
  • UK Brass Band & Salvation Army Brass band templates
  • New drumset file for French drum notation (#14340)
  • Ability to move lyrics with left and right arrows
  • Internationalization of the MuseScore.com plugin ("Save Online") and translation to French, German and Spanish

Supported platforms

On Mac, MuseScore 1.2 is released in binary form only for Mac OS X 10.6+ running an Intel processor.

Bug fixes

Playback

  • fix #11479: playback swing of quarter notes on counter beat
  • default reverb/chorus to minimum
  • fix #10331: In playback, note(s) do not stop when they should (repeat & note offtime)

Style

  • fix #15147: Style Page Nums "show first" not checked, 1st page > 1: 1st page number still shown (mi)
  • fix default style of Frame Text
  • fix #7017: german chordnames (H / Bb)

Parts

  • Extract voltas correctly
  • fix #15059: save a newly created part doesn't remove the asterisk
  • fix #13357: Creating part causes crash (key sig corruption)
  • fix #12322: Exported parts close on command without a warning

User Interface

  • remove subbeam button
  • add Frame Text to Vertical Frame
  • use English note name in Edit Drumset dialog
  • change default drumset folder to "templates" dir
  • fix slur properties dialog title
  • translation of "staff properties" on instrument name
  • fix #15228: add perfect octave up and down
  • fix #15132: Create new score and quit/reopen presents incorrect dialog
  • fix #14648: Disallow copy of part of tuplets
  • fix #14992: Inserting measures corrupts score with tuplets
  • fix #3482: pasting after copy/cut creates note with wrong duration
  • fix #14409: Crash on copying tuplets
  • fix #14272: Add 'Can't open" dialog for unknown filetype
  • fix #14076: Add MuseScore.org link in dialog for more recent file
  • fix #14036: Background Wallpaper Distortion
  • fix #13478: Zoom during playback using shortcuts
  • fix #13364: Score tabs disappear
  • fix #12161: Changing time signature should change autobeam properties
  • fix #12084: Crash when running transpose with title selected
  • fix translation of context menu on keysig
  • fix #15283: Paste and undo causes crash
  • fix #15460: Note Names without score causes crash
  • fix #15461: Remove Notes without score causes crash
  • fix #15458: Break Every X Measures without score causes crash
  • fix #15457: Undo Insert Measure after changing clef causes crash

Notation

  • fix #15123: Measure rest should be shown as breve if measure >= 4/2
  • fix #14917: Wrong bracket in nested tuplet
  • fix #14973: Transparent and truly vectorial embedded SVG
  • fix #14429: Articulations / ornaments in small staves are not small
  • fix #14420: Measures long 2/1 or more not cleared to measure rest
  • add two more chord names: sus#4 & Maj7b13
  • fix #10552: no more crash on undo, dynamic created
  • Incomplete fix #12966: Measure insert corrupts key changes
  • fix #5433: Staff with one line and repeat bars are not aligned
  • fix #4157: regression : Natural after a tie across barline
  • fix #1395: Accidental after a tied note
  • fix #12085: Enharmonics not preserved when toggling concert pitch in part > 1 octave
  • fix #12218: shaped noteheads aren't shared
  • fix #12419: Ledger lines are still visible for invisible notes
  • fix #11926: Pedal marking created in 1.0 are displayed incorrectly in MuseScore 1.1
  • fix #4893: Non-removable courtesy clef appears after insert measure before first one
  • fix #14648: disallow copy of partial tuplets

Import/Export

  • export MIDI with relative tempo set in Play Panel
  • fix pedal ending in MIDI export #12642
  • fix #13107: bww import: missing bagpipe doublings
  • fix crash on MIDI import for some files
  • fix #14064: crash on Capella import for some files
  • fix #7352: basic Triplet support for Capella import

Packaging and updates

  • add "Create desktop shortcut" option in Windows installer
  • reduce auto update check period

MusicXML import and export

  • reworked MusicXML voice mapper
  • add dynamic and note velocity support in MusicXML export/import
  • fix #11927: Export duplicate chordnames
  • fix #15129: Empty measures are not imported
  • fix #11675: Crash opening MusicXML from Finale
  • fix #12276: Sub-optimal handling of different duration measures on import
  • fix #12394: Chordnames are not exported for grand staff
  • fix #12382: Key Signature for 2 Staves
  • fix crash reading MusicXML file with different key signatures on the first and second staffs
  • add MusicXML testfile for issue #12382 ("Key Signature for 2 Staves")
  • fix #13183: Wrong import of right barline
  • add testfile for #13860: Support lyrics exported by Sibelius 7
  • fix #13782: Errors in Import and Crash after closing
  • fix #5947: Slurs is not well placed with grace note
  • fix #12445: Import can produce empty voice 1: set (automativally) generated rests to invisible
  • fix #12349: Wrong placed slurs after importing a MusicXML file
  • fix #12445: Import can produce empty voice 1
  • fix "variable set but not used" warnings in importxml.cpp
  • fix #11221: Don't set "Break multi measure rest" when importing from MusicXML
  • fix #13860: support lyrics exported by Sibelius 7
  • updated MusicXML testfiles: added sound dynamics="..."
  • fix #14088: Problem importing triplets from XML if tuplet element is missing
  • fix #14160: Problem importing tuplets from XML in a multi-voice context
  • fix #14118: Import of tuplets containing chords is incorrect
  • fix #14692: import error: 41g-PartNoId.xml causes crash
  • fix #14693: import error: 41h-TooManyParts.xml causes crash
  • fix #14828: import error: 46a-Barlines.xml: unexpected multi-measure rests
  • fix #14834: import error: 45e-Repeats-Nested-Alternatives.xml: repeat start missing
  • fix #14827: import error: 32a-Notations.xml: missing notations
  • fix #14862: Export notations imported by issue #14827
  • fix #14819: import error: 01f-Pitches-ParenthesizedMicrotoneAccidentals.xml imports without microtone accidentals
  • fix #14818: import error: 01e-Pitches-ParenthesizedAccidentals.xml imports without double flat in parentheses
  • fix #14832: import error: 41d-StaffGroups-Nested.xml: part-group symbol=line not supported
  • fix #14804: Bad pitch and alter exported for cross staff note
  • fix #14418: Voltas lost when importing MusicXML
  • fix #14701: Key signature is not exported from a mscz saved with 1.1
  • fix #14244: Export of trill line fails
  • fix #14825: import error: 31a-Directions.xml missing dashes and bracket
  • fix #15002: Export/import of uneven tuplets (16th, eighth, eighth, 16th)
  • fix #15033: Handle tuplet property "number"
  • support parentheses attribute for accidentals (preferred as of MusicXML 1.1)
  • import export volume and pan for each instrument
  • minimal support of page relative text on first page in import and export
  • fix #14590: import errors 23a-Tuplets.xml
  • fix #14451: import errors 02a-Rests-Durations.xml
  • fix #15325: Notes are interpreted as rests, wrong lengths, strange results
  • don't import tempo 0 as tempo text

Miscellaneous

  • fix #6649: Transposition when creating a score from a template
  • fix: Offset for offtime not saved
  • changes to tuplet handling to allow reading of corrupted files (#13350)

Plugin Framework

  • fix #13301: add score.close() to plugin framework
  • add score.version and score.fileVersion
  • add ability to test for no current score

Release notes for MuseScore 1.3

MuseScore 1.3 is mainly a bug fix release. Two bugs causing a major nuisance and a dozen of smaller ones have been fixed. No new features have been added. The translations and the handbooks have been updated.

Bug fixes

Playback

  • Fix #19148: Distortion in sound playback after several measures of play due to reverb
  • Improve the stability of the sequencer and user interface interaction

Crashes

  • Fix crash when loading files with invalid tuplet
  • Fix crash when exporting parts with voltas
  • Fix possible crash during MusicXML import
  • Fix crash when changing voices without valid input state

User Interface

  • Fix #16692: Save and Save As dialogue boxes fail to open when Title contains colon
  • Fix last element in file format combo box in the File -> Open Dialog is empty on Mac OS X
  • Fix Two percussion clefs in palette
  • Fix #16301: Verbose program listing in Add/Remove Programs
  • Change default shortcut for voices to Ctrl + Alt + Voice number (Previous shortcuts were not working on Mac)
  • Fix small icons on Windows and Mac
  • Add 1024x1024 icons on Mac OSX for retina display
  • Fix: Fermata applied to rest isn’t positioned where it was placed until score is saved and re-opened
  • Better looking new score wizard on Mac OS X
  • Fix: Two invisible boxes in 'Lines'

Updates

Installer

  • Windows binaries are now signed with an Authenticode certificate
  • Windows installer is also available in MSI format to ease the deployment of MuseScore through Group Policy
  • Both Windows installers are signed with an Authenticode certificate

Plugins

  • Updated musescore.com “Save online” plugin, cosmetic changes
  • Updated ABC import plugin, support for larger files

MuseScore 1.3 is packaged with Qt 4.8.4 on Windows and Mac OS X.

Music Hack Day

Music Hack Day is a regular gathering for music and tech people. During this event, programmers, designers, thinkers of all over the world meet up and try to create music related software or hardware hacks during a 24 hours coding marathon. The core team of MuseScore contributors, namely Werner Schweer, Thomas Bonte and Nicolas Froment are regular attendees of the Music Hack Days. They promote MuseScore and MuseScore.com, empower other coders to create something with one of the following resources:

Upcoming hackdays

All upcoming hackdays listed at http://musichackday.org

Previous hackdays

Below is the list of Music Hack Days where MuseScore was represented, as well as the resulting hacks.

Barcelona June 12-13 2014

http://new.musichackday.org/2014/barcelona/
Attending: Nicolas - Thomas

London 7 - 8 December 2013

http://london.musichackday.org/2013
Attending: Thomas - Nicolas - ChenLung - Manuel Bärenz

Bologna 5 - 6 October 2013

http://bologna.musichackday.org/index.php?page=Main+page
Attending: Miwarre - Thomas - Nicolas - Werner

Munich 27 - 28 July 2013

http://hackday.peachnote.com/
Attending: Thomas Bonte - Paul Sebastien - Florian Weiss - Nicolas (remote)

Denver 20 - 21 July 2013

http://denver.musichackday.org/index.php?page=Main+page
Attending: Marc Sabatella

Barcelona 13 - 14 June 2013

Attending: Thomas - Nicolas - Werner - Paul Sebastien

Vienna 1st - 3rd February 2013

Attending: Thomas - Nicolas - Werner
Site: http://classicalmusichackday.org

Cannes 26th - 27th January 2013

Attending: Nicolas
Site: http://cannes.musichackday.org/2013

Barcelona 14th - 15th June 2012

Nicolas - Thomas - Kaspar - Quim Llimona & Sara Gozalo

Blog post: Hello from Barcelona

Cannes 29th - 30th January 2012

Thomas - Mathieu Barthet

London 3rd - 4th December 2011

Thomas - Nicolas - Joachim Ganseman - Richard Lewis - Keith Moon - Andrew Robertson

Boston 5th - 6th November 2011

Thomas - Nicolas - Matthias Röder - Vladimir Viro - Hervé Bitteur

Barcelona (Sonar) 16th - 17th June 2011

Thomas - Nicolas - Bram de Jong

Berlin 28th - 29th May 2011

Thomas - Nicolas - Werner

San Francisco 7th - 8th May 2011

Thomas - Nicolas - Lucas Gonze - Pieter-Jan Vaernewijck

New York 12th - 13th February 2011

Thomas - Nicolas - Matt Prokup

Cannes 23rd - 24th January 2011

Thomas - Nicolas (remote)

Barcelona 2nd - 3rd October 2010

Thomas - Nicolas - Joachim Ganseman

London 4th - 5th September 2010

Thomas - Nicolas - Werner

San Francisco 15th - 16th May 2010

Thomas - Nicolas - Joachim Ganseman

Amsterdam 24th - 25th April 2010

Thomas - Nicolas

Amsterdam 21st October 2009

Thomas - Nicolas (remote)