I did this a while back with the intent to build a language service for
.RGS files (to colorize them), but never did finish it up. I did get it
wired up properly though, at least to the point of dumping the text from
IVsColorizer::ColorizeLine to Trace.WriteLine :-)

Basically I had two classes (RGSColorizer which is derived from
IVsColorizer, and RGSLanguageService which is derived from
IVsLanguageInfo). The RGSLanguageService is decorated with a Guid
attribute. For example:

  [Guid("BE8FD236-8677-4625-9E3C-F5A2E521CBF0")]
  public class RGSLanguageService : IVsLanguageInfo
  {  ...  }

To register the language service I derived a new class from
RegistrationAttribute (see below) to set up the registry keys. Then it was
just a matter of proffering the service in my package object's Initialize
method which looked like the following:

     ...
     [ProvideLanguageService("RGS Language Service",
typeof(RGSLanguageService), ".rgs", typeof(RGSServices), 300)]
     ....
     public class RGSServices : MSVSIP.Helper.Package, IVsInstalledProduct
     {
        ..........
       protected override void Initialize()
       {
           Trace.WriteLine (string.Format("Entering Initialize() of: {0}",
this.ToString()));
           base.Initialize();
 
           // Create and proffer the language service
           languageService = new RGSLanguageService(this);
           ((IServiceContainer)this).AddService(languageService.GetType(),
languageService, true);
        }
      ...........
     }

    [AttributeUsage(AttributeTargets.Class, AllowMultiple=true,
Inherited=true)]
    public class ProvideLanguageServiceAttribute : RegistrationAttribute
    {
        private string langName;
        private string guidLangService;
        private uint   langResID;
        private string guidPackage;
        private string fileextensions;  // ; delimited. for example:
".rgs;.txt;.cpp"

        private uint showCompletion;
        private uint showSmartIndent;
        private uint requestStockColors;
        private uint showHotURLs;
        private uint defaultToNonHotURLs;
        private uint defaultToInsertSpaces;
        private uint showDropdownBarOption;
        private uint singleCodeWindowOnly;
        private uint enableAdvMembersOption;
        private uint supportCF_HTML;
   
        private string GetGuidStrFromObject(object obj)
        {
            if (obj is string)
                return (string)obj;
            else if (obj is Type)
                return ((Type)obj).GUID.ToString("B");
            else if (obj is Guid)
                return ((Guid)obj).ToString("B");
            else
                throw new ArgumentException("Invalid ProvideLanguageService argument!");
        }

        public ProvideLanguageServiceAttribute(string langName, object
guidLangService, string fileextensions, object guidPackage, uint langResID)
        {
            this.langName = langName;
            this.fileextensions = fileextensions;
            this.langResID = langResID;
            this.guidLangService = GetGuidStrFromObject(guidLangService);
            this.guidPackage = GetGuidStrFromObject(guidPackage);
           
            this.showCompletion = 0;
            this.showSmartIndent = 0;
            this.requestStockColors = 0;
            this.showHotURLs = 0;
            this.defaultToNonHotURLs = 0;
            this.defaultToInsertSpaces = 0;
            this.showDropdownBarOption = 0;
            this.singleCodeWindowOnly = 1;
            this.enableAdvMembersOption = 0;
            this.supportCF_HTML = 0;
        }

        #region Properties
       
        public bool ShowCompletion
        {
            get
            {
                return showCompletion > 0;
            }
            set
            {
                if (value) showCompletion = 1;
                else showCompletion = 0;
            }
        }

        public bool ShowSmartIndent
        {
            get
            {
                return showSmartIndent > 0;
            }
            set
            {
                if (value) showSmartIndent = 1;
                else showSmartIndent = 0;
            }
        }

        public bool RequestStockColors
        {
            get
            {
                return requestStockColors > 0;
            }
            set
            {
                if (value) requestStockColors = 1;
                else requestStockColors = 0;
            }
        }

        public bool ShowHotURLs
        {
            get
            {
                return showHotURLs > 0;
            }
            set
            {
                if (value) showHotURLs = 1;
                else showHotURLs = 0;
            }       
        }

        public bool DefaultToNonHotURLs
        {
            get
            {
                return defaultToNonHotURLs > 0;
            }
            set
            {
                if (value) defaultToNonHotURLs = 1;
                else defaultToNonHotURLs = 0;
            }
        }

        public bool DefaultToInsertSpaces
        {
            get
            {
                return defaultToInsertSpaces > 0;
            }
            set
            {
                if (value) defaultToInsertSpaces = 1;
                else defaultToInsertSpaces = 0;
            }
        }

        public bool ShowDropdownBarOption
        {
            get
            {
                return showDropdownBarOption > 0;
            }
            set
            {
                if (value) showDropdownBarOption = 1;
                else showDropdownBarOption = 0;
            }
        }

        public bool SingleCodeWindowOnly
        {
            get
            {
                return singleCodeWindowOnly > 0;
            }
            set
            {
                if (value) singleCodeWindowOnly = 1;
                else singleCodeWindowOnly = 0;
            }
        }
       
        public bool EnableAdvMembersOption
        {
            get
            {
                return enableAdvMembersOption > 0;
            }
            set
            {
                if (value) enableAdvMembersOption = 1;
                else enableAdvMembersOption = 0;
            }
        }
       
        public bool SupportCF_HTML
        {
            get
            {
                return supportCF_HTML > 0;
            }
            set
            {
                if (value) supportCF_HTML = 1;
                else supportCF_HTML = 0;
            }
        }

        #endregion Properties

        public override void Register(RegistrationContext context)
        {
            // Register Language Service settings under <VS Reg
Root>\Languages\Languages Services\<langsvc name>
            string regKeyName = string.Format("Languages\\Language Services\\{0}",
langName);
            Key key = context.CreateKey(regKeyName);
            key.SetValue("", guidLangService);
            key.SetValue("LangResID", langResID);
            key.SetValue("Package", guidPackage);
            key.SetValue("ShowCompletion", showCompletion);
            key.SetValue("ShowSmartIndent", showSmartIndent);
            key.SetValue("RequestStockColors", requestStockColors);
            key.SetValue("ShowHotURLs", showHotURLs);
            key.SetValue("Default to Non Hot URLs", defaultToNonHotURLs);
            key.SetValue("DefaultToInsertSpaces", defaultToInsertSpaces);
            key.SetValue("ShowDropdownBarOption", showDropdownBarOption);
            key.SetValue("Single Code Window Only", singleCodeWindowOnly);
            key.SetValue("EnableAdvancedMembersOption", enableAdvMembersOption);
            key.SetValue("Support CF_HTML", supportCF_HTML);
            key.Close();

            // Register File extensions under <VS Reg Root>\Languages\File
Extensions\<file extension>
            char[] delimiters = {' ' , ',' , '.' , ':' , ';'};
            string[] extensions = fileextensions.Split(delimiters,10);
            foreach (string s in extensions)
            {
                regKeyName = string.Format("Languages\\File Extensions\\.{0}", s);
                key = context.CreateKey(regKeyName);
                key.SetValue("", guidLangService);
                key.Close();
            }

            // Register language service under <VS Reg Root>\Services<langsvc guid>
            regKeyName = string.Format("Services\\{0}", guidLangService);
            key = context.CreateKey(regKeyName);
            key.SetValue("", guidPackage);
            key.SetValue("Name", langName);
            key.Close();
        }

        public override void Unregister(RegistrationContext context)
        {
            // Remove <VS Reg Root>\Languages\Language Services\<langName> key
            string regKeyName = string.Format("Languages\\Language Services\\{0}",
langName);
            context.RemoveKey(regKeyName);

            // Remove file extensions <VS Reg Root>\Languages\File Extensions\<file
extension>
            char[] delimiters = {' ' , ',' , '.' , ':' , ';'};
            string[] extensions = fileextensions.Split(delimiters,10);
            foreach (string s in extensions)
            {
                regKeyName = string.Format("Languages\\File Extensions\\.{0}", s);
                context.RemoveKey(regKeyName);
            }   

            // Remove entry under <VS Reg Root>\Services<langsvc guid>
            regKeyName = string.Format("Services\\{0}", guidLangService);
            context.RemoveKey(regKeyName);
        }

    }

Hopefully, that'll get you pointed in the right direction.

Sincerely,
Ed Dore [MSFT]

This post is 'AS IS' with no warranties, and confers no rights.