The following tip is not new; it is based on this post and its comments. However, for the sake of completeness and for future reference, I bring here the final version.

The question this posts tries to address is: Where to put value converters?

Normal Solution

Usually, the common place to put value converters is in the resources section. With this in place, you can use the value converter with StaticResource syntax:

<UserControl.Resources>
    <local:NotConverter x:Key="notConverter" />
</UserControl.Resources>

...

<StackPanel>
    <Button IsEnabled="{Binding Converter={StaticResource notConverter}}" />
</StackPanel>

This means that every time you want to use the value converter, you need to add it to the resources section. A better place is to put it in a global converters resource file, so the resource definition is only done once.

Creative Solution

In short, have your converter derive from MarkupExtension. This will avoid the question altogether. The complete solution provides a generic base class you should derive from, ConverterMarkupExtension. The advantages of deriving from this class are:

Your converter can be used as a markup extension. So the former code becomes:
```
<StackPanel>
    <Button IsEnabled="{Binding Converter={local:notConverter}}" />
</StackPanel>
```
Specifically, no resource definition is needed. At all.
Only one instance of your converter is used to provide the value (sort of singleton).
Note that every time the XAML compiler see a markup extension, it will create a new instance, BUT the following implementation always return the same single converter. If you are worried about all the short lived instances of the markup extension, just consider that using StaticResource (another markup extension) would have created them anyway. So there is no additional stress on memory consumption.
The base class provides default implementation for both IValueConverter and IMultiValueConverter methods. It throws NotImplementedException. This doesn’t seem much but helps shorten your converter code in the usual case when you implement only one conversion direction.

ConverterMarkupExtension, Short Version for Clarity

public abstract class ConverterMarkupExtension<T> : MarkupExtension, IValueConverter,
    IMultiValueConverter
        where T : class, new()
    {
        private static T _converter = null; 

        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            if (_converter == null)
            {
                _converter = new T();
            }

            return _converter;
        }

        #region IValueConverter Members

        public virtual object Convert(object value, Type targetType, object parameter,
            CultureInfo culture)
        {
            throw new NotImplementedException();
        }

        public virtual object ConvertBack(object value, Type targetType,
            object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }

        #endregion

        #region IMultiValueConverter Members

        ...
        
        #endregion

Here, you can get the full version of the code including lots of comments.

Using the Base Class

Following is an example of how to use ConverterMarkupExtension to implement your own converter:

using System;
using System.Windows.Data;
using System.Globalization;

namespace WPF.Common
{
    /// <summary>
    /// Returns the negation of the given boolean value
    /// </summary>
    public class NotConverter : ConverterMarkupExtension<NotConverter>
    {
        public override object Convert(object value, Type targetType, object parameter,
            CultureInfo culture)
        {
            return !(bool)value;
        }
    }
}

Note that the value converter code remains practically the same, but you get the ability to use it as a markup extension and remove the "not implemented" section.

That’s it for now,
Arik Poznanski.

WPF: Where to Put Value Converters?