These questions have been addressed multiple times and are not new :p

Kurt wrote:

In a situation where one has most libraries full and is using all of the sample memory, and one has made performances in User and also in some of the libraries that point to waveforms in library X, if I remove library X in order to make room to load another library as a test, when I then delete the test library and re-load the old library X will the performances in User and the other libraries point to library X again?

No, you will lose the connection.

Kurt wrote:
Or will these performances in user and the other libraries that once pointed to library X not be able to find them?

Correct. You have to import Library Waveforms or Performances into User before saving them if you ever want to retain any connection between the Part and it's Waveforms.

Kurt wrote:
Actually, also related to data management, if one is editing a performance in User and adds a part to that performance from a library, when the performance is saved in User does the Montage import that library part and any associated waveforms into User or just point that part to the library?

It just points, hence the answers given above^.

Hi

A user performance don't 'find' or 'lose' a 'connection' with a library waveform.
In a performance you have a pointer to the waveform.
This pointer consist in a bank number (preset, user, libraies) and an offset in that bank. (See datalist page 210 'wave select' and 'wave number').
if you delete (unmount) a library, this pointer is unchanged, it is simply wrong.
If you reload the library the pointer, always unchanged, is now 'true'.

The problem is we have no control on the slot (bank) number Montage use when we load a library.
Whe we load a library, Montage use the first slot available.

So imagine a scenario:
You have load (1):libA, (2):libB, (3):libC, (4):libD
You make a user performance that use a waveform of libD.
After a time you delete libB because you don't like it.
Then, after a time, you delete libD to free memory because libD have very large samples and you want to test libX.
So after deleting libD, you load libX and after testing libX you delete libX and reload libD.
LibD is now in slot(2) and the pointer of your user performance is now wrong.

In case of this problem, I delete (unmount) all my libraries and reload it in the same order (in this exemple : libA then libB then libC then libD)

Fortunately when you merge performances there is no import of the lib's waveforms, otherwise you waste quickly memory.

This is the same for arpeggios.

To import waveform or arpeggio you have to import a performance that use this waveform or arpeggio (via Utility>Contents>Library import)

Thank you Jean! That is exactly what I was looking for. Your post should be a sticky. I will check out the data list page 210.

Joe, I understand you were teasing and I take no offense, and thank you for your reply, but from the correction of Jean you can see why these questions are re-asked. There is a lot of misinformation out there and searching through the posts (which I did for awhile trying to find answers to this and other library questions) didn't get me the answers I needed. Sometimes I search for an hour on a question and just go test it to get the results. How many others are doing this? Yamaha really needs to put out a FAQ or manual addendum with all the ways that libraries and pointers work, what is lost in any file operations such as user motion curves and micro-tunings and attach that to Bad Mister's definitive initial post on the subject (which I think was made into an article on this site expanding how and when to use libraries, user, and load, import and save operations).

Spoff

I believe this is the link to Bad Mister's original article on the subject for those who have other questions: https://yamahasynth.com/blog/user-and-library

Spoff

As simple as it is to save a library performance as a user performance (instead of importing) in order to start modifying a custom version of the performance - I have previously said "never" to do this. If using library-based waveforms in the original performance, this is one instance where the pointers now rely on library to be loaded in a specific slot and your user performance can become disassociated with its data.

I've actually said this more of live sets - but my notion is that data should strive to be self contained. Anything loaded in a library should only be library-based meaning the full data (which was formerly user) - all waveforms, all performance data, all live-set related to these performances - should live in library. You do this by generating a library from "pure" user data.

"Pure" user data is one that - if the performance at any time started as a library - was all imported into user and not copied (saved).

I would strive for data that if I "unmounted" a library - then no other performances would depend on any of this data. And all data (user, library) is "all or nothing". Meaning each area is self-contained and does not point to another area.

Delete

Jason,

I agree in principal that is the best practice. But for exceptions where you have so many waveforms in your libraries that your memory is full and thus one can't import more waveforms from the library to User (as this would take up more space) it is feasible to work with 8 loaded libraries using pointers to the waveforms in them. The important thing one can do in such a situation though is to use that as a whole other set that you do a total backup of the Montage for. Then everything will always load correctly when you restore then entire set. Time consuming yes, but it works. And for most of the time consuming operations I just do it ahead of time or while doing something else so no time is wasted.

That being set I would also keep original copies of the self-contained libraries and user files separate so you can have environments where you work from them as well, and always have them to go back to without having to worry about missing links. But my intention is to mainly work the way Jean stated, which is that is long as my libraries as pretty set in stone and loaded in the same order I don't have to worry about missing pointers.

A nice thing about the Montage is that you can do things in different ways.

Spoff

Maybe there are cases where this is true. I have difficulty coming up with examples that couldn't be refactored -- but I trust they exist if you express running into these brick walls. The good thing is you have a system that works. I stick by the advice that one should strive for pointer alignment (performances only pointing to waveform in the performance's own save location).

Hi

This is why I add the screen 'Perf infos' in my soft to see the dependencies of a performance and I add these infos in the main screen of the catalog.

For exemple if you start working by creating a performance who have dependencies on librairies and then, later, you decide to share it or using it in your own library and so you want a 'pure' performance.

(The initial dump with my soft take times and it works only on PC)