diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 31c5ccdce..116ed9db0 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,8 +1,6 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
     <Objective-C>
-      <option name="INDENT_PREPROCESSOR_DIRECTIVE" value="4" />
-      <option name="INDENT_DIRECTIVE_AS_CODE" value="true" />
       <option name="KEEP_CASE_EXPRESSIONS_IN_ONE_LINE" value="true" />
       <option name="KEEP_DIRECTIVE_AT_FIRST_COLUMN" value="false" />
       <option name="NAMESPACE_BRACE_PLACEMENT" value="2" />
@@ -26,6 +24,7 @@
       <option name="CLASS_CONSTRUCTOR_INIT_LIST_NEW_LINE_BEFORE_COLON" value="1" />
       <option name="SUPERCLASS_LIST_WRAP" value="1" />
       <option name="ALIGN_INIT_LIST_IN_COLUMNS" value="false" />
+      <option name="ENUM_CONSTANTS_COMMA_ON_NEXT_LINE" value="true" />
       <option name="SPACE_WITHIN_FUNCTION_DECLARATION_PARENTHESES" value="true" />
       <option name="SPACE_WITHIN_FUNCTION_CALL_PARENTHESES" value="true" />
       <option name="SPACE_BEFORE_PROTOCOLS_BRACKETS" value="false" />
@@ -78,6 +77,7 @@
       <option name="DOWHILE_BRACE_FORCE" value="3" />
       <option name="WHILE_BRACE_FORCE" value="3" />
       <option name="FOR_BRACE_FORCE" value="3" />
+      <option name="ENUM_CONSTANTS_WRAP" value="0" />
       <indentOptions>
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
         <option name="LABEL_INDENT_ABSOLUTE" value="true" />
diff --git a/Sourcecode/include/mx/api/ApiEquality.h b/Sourcecode/include/mx/api/ApiEquality.h
index 938c5f0ba..d85937681 100644
--- a/Sourcecode/include/mx/api/ApiEquality.h
+++ b/Sourcecode/include/mx/api/ApiEquality.h
@@ -9,17 +9,12 @@
 #include <map>
 #include <iostream>
 
+// #define MX_DEBUG // shows traces to std::cout
+
 namespace mx
 {
     namespace api
     {
-        
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// All of the uglines below this point is mainly to be used in test code.  It is not expected that clients will have need of the //
-// functions defined here.  If you do wish to use the equality operator, you may want to silence the cout's that occur when two  //
-// items are found to be not-equal.  This cout stream was necessary for testing during development.                              //
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
         template <typename T>
         inline bool areVectorsEqual( const std::vector<T>& lhs, const std::vector<T>& rhs )
         {
@@ -72,6 +67,7 @@ namespace mx
             return areSame( lhs, rhs );
         }
 
+#ifdef MX_DEBUG
         inline void streamComparisonUnequalMessage( const char* const inClassName, const char* const inMemberName )
         {
             std::cout << inClassName;
@@ -80,23 +76,30 @@ namespace mx
             std::cout << " members are not equal ";
             std::cout << std::endl;
         }
-        
+#endif
+
+#ifdef MX_DEBUG
+    #define MX_SHOW_UNEQUAL( XtheCurrentClassName, XmxapiMemberName ) streamComparisonUnequalMessage( XtheCurrentClassName, XmxapiMemberName );
+#else
+    #define MX_SHOW_UNEQUAL( XtheCurrentClassName, XmxapiMemberName )
+#endif
+
 #define MXAPI_EQUALS_BEGIN( mxapiClassName ) \
         inline bool operator==( const mxapiClassName& lhs, const mxapiClassName& rhs ) \
         { \
             const char* const theCurrentClassName = #mxapiClassName;
-
+            
 #define MXAPI_EQUALS_MEMBER( mxapiMemberName ) \
         if( ! ( lhs.mxapiMemberName == rhs.mxapiMemberName ) ) \
         { \
-            streamComparisonUnequalMessage( theCurrentClassName, #mxapiMemberName ); \
+            MX_SHOW_UNEQUAL( theCurrentClassName, #mxapiMemberName ); \
             return false; \
         }
 
 #define MXAPI_DOUBLES_EQUALS_MEMBER( mxapiMemberName ) \
         if( std::abs( lhs.mxapiMemberName - rhs.mxapiMemberName ) > MX_API_EQUALITY_EPSILON ) \
         { \
-            streamComparisonUnequalMessage( theCurrentClassName, #mxapiMemberName ); \
+            MX_SHOW_UNEQUAL( theCurrentClassName, #mxapiMemberName ); \
             return false; \
         }
 
diff --git a/Sourcecode/include/mx/api/FontData.h b/Sourcecode/include/mx/api/FontData.h
index 909e6a4f3..4ce5697c3 100644
--- a/Sourcecode/include/mx/api/FontData.h
+++ b/Sourcecode/include/mx/api/FontData.h
@@ -96,7 +96,7 @@ namespace mx
         MXAPI_EQUALS_MEMBER( weight )
         if( ! areVectorsEqual( lhs.fontFamily, rhs.fontFamily ) )
         {
-            streamComparisonUnequalMessage( "FontData", "fontFamily" );
+            MX_SHOW_UNEQUAL( "FontData", "fontFamily" );
             return false;
         }
         MXAPI_EQUALS_MEMBER( underline )
diff --git a/Sourcecode/include/mx/api/KeyComponent.h b/Sourcecode/include/mx/api/KeyComponent.h
new file mode 100644
index 000000000..1720f6001
--- /dev/null
+++ b/Sourcecode/include/mx/api/KeyComponent.h
@@ -0,0 +1,42 @@
+// MusicXML Class Library
+// Copyright (c) by Matthew James Briggs
+// Distributed under the MIT License
+
+#pragma once
+#include "mx/api/ApiCommon.h"
+#include "mx/api/PitchData.h"
+
+namespace mx
+{
+    namespace api
+    {
+
+        // KeyComponent is only used for non-traditional key signatures. It facilitates specifying the
+        // exact accidentals that are found in the key signature.
+        struct KeyComponent
+        {
+            // The note name that is to be altered by the key signature.
+            Step step;
+
+            // The amount that notes of this note name should be altered, in semitones.
+            int alter;
+
+            // Additional amount that notes of this note name should be altered, in cents. If alter = 1 and cents = 25.1
+            // then the note is altered by 1.251 semitones in total.
+            double cents;
+
+            // The accidental to display for this note name.
+            Accidental accidental;
+        };
+
+
+        MXAPI_EQUALS_BEGIN( KeyComponent )
+        MXAPI_EQUALS_MEMBER( step )
+        MXAPI_EQUALS_MEMBER( alter )
+        MXAPI_EQUALS_MEMBER( cents )
+        MXAPI_EQUALS_MEMBER( accidental )
+        MXAPI_EQUALS_END;
+
+        MXAPI_NOT_EQUALS_AND_VECTORS( KeyComponent );
+    }
+}
diff --git a/Sourcecode/include/mx/api/KeyData.h b/Sourcecode/include/mx/api/KeyData.h
index 05618f7f8..64464c60a 100644
--- a/Sourcecode/include/mx/api/KeyData.h
+++ b/Sourcecode/include/mx/api/KeyData.h
@@ -3,72 +3,101 @@
 // Distributed under the MIT License
 
 #pragma once
+#include "mx/api/KeyComponent.h"
 
 namespace mx
 {
-	namespace api
-	{
+    namespace api
+    {
         enum class KeyMode
         {
-            // a mode value was not provided
-            unspecified,
-            
-            // a mode value was provided but
-            // is not supported
-            unsupported,
-            
+            unspecified, // a mode value was not provided
+            unsupported, // a mode value was provided but is not supported
             major,
             minor
-            
         };
-		struct KeyData
-		{
-			// From MusicXML Specification:
-			// The fifths type represents the number of flats or sharps in a
-			// traditional key signature. Negative numbers are used for flats
-			// and positive numbers for sharps, reflecting the key's
-			// placement within the circle of fifths (hence the type name).
-			int fifths;
 
-			// From MusicXML Specification:
-			// A cancel element indicates that the old key signature should be
-			// cancelled before the new one appears. This will always happen
-			// when changing to C major or A minor and need not be specified
-			// then. The cancel value matches the fifths value of the cancelled
-			// key signature (e.g., a cancel of -2 will provide an explicit
-			// cancellation for changing from B flat major to F major). The
-			// optional location attribute indicates whether the cancellation
-			// appears relative to the new key signature.
-			int cancel;
+        // KeyData represents a key signature. It can be in one of two configurations. Either you specify
+        // 'fifths' and 'mode', or you can create a custom key signature by adding items to the customKey
+        // vector. If anything is found in the customKey vector, then fifths and mode will be ignored.
+        //
+        // Example, a traditional key signature (D Major):
+        // KeyData key;
+        // key.fifths = 2; // (i.e. 2 sharps)
+        // key.mode = KeyMode::major; // (optional)
+        //
+        // Example, a traditional key signature (G Minor):
+        // KeyData key;
+        // key.fifths = -2; // (i.e. 2 flats)
+        // key.mode = KeyMode::minor; // (optional)
+        //
+        // If you want to create a custom time signature, you can do so like this. Here we are creating a
+        // key where C's are sharp and D's are one-quarter-tone sharp. See KeyComponent for details.
+        //
+        // KeyComponent cSharp{ Step::c, 1, 0.0, Accidental::sharp };
+        // KeyComponent dQuarterTone{ Step::d, 0, 50.0, Accidental:quarterSharp };
+        // KeyData key;
+        // key.nonTraditional.push_back( cSharp );
+        // key.nonTraditional.push_back( dQuarterTone );
+        //
+        struct KeyData
+        {
+            // From MusicXML Specification:
+            // The fifths type represents the number of flats or sharps in a
+            // traditional key signature. Negative numbers are used for flats
+            // and positive numbers for sharps, reflecting the key's
+            // placement within the circle of fifths (hence the type name).
+            int fifths;
+
+            // From MusicXML Specification:
+            // A cancel element indicates that the old key signature should be
+            // cancelled before the new one appears. This will always happen
+            // when changing to C major or A minor and need not be specified
+            // then. The cancel value matches the fifths value of the cancelled
+            // key signature (e.g., a cancel of -2 will provide an explicit
+            // cancellation for changing from B flat major to F major). The
+            // optional location attribute indicates whether the cancellation
+            // appears relative to the new key signature.
+            int cancel;
 
+            // Mode specifies whether the key is major or minor. It is optional.
             KeyMode mode;
+
+            // Supports changing the key somewhere other than at the start of a measure.
             int tickTimePosition;
-            
+
             // this value is optional. -1 means unspecified. when value is
             // unspecified it means that the key signature applies to all staves
             // within the part
             int staffIndex;
-            
-			// TODO support position data and/or other attribtues
-            
+
+            // TODO support position data and/or other attributes
+
+            // Supports the creation of customized, non-traditional key signatures by specifying the exact note
+            // alterations. When custom is non-empty, then fifths and mode are ignored.
+            std::vector<KeyComponent> nonTraditional;
+
             KeyData()
             : fifths{ 0 }
             , cancel{ 0 }
             , mode{ KeyMode::unspecified }
             , tickTimePosition{ 0 }
             , staffIndex{ -1 }
+            , nonTraditional{}
             {
-                
+
             }
-		};
-        
+        };
+
         MXAPI_EQUALS_BEGIN( KeyData )
         MXAPI_EQUALS_MEMBER( fifths )
         MXAPI_EQUALS_MEMBER( cancel )
         MXAPI_EQUALS_MEMBER( mode )
         MXAPI_EQUALS_MEMBER( tickTimePosition )
         MXAPI_EQUALS_MEMBER( staffIndex )
+        MXAPI_EQUALS_MEMBER( nonTraditional )
         MXAPI_EQUALS_END;
+
         MXAPI_NOT_EQUALS_AND_VECTORS( KeyData );
-	}
+    }
 }
diff --git a/Sourcecode/include/mx/api/StaffData.h b/Sourcecode/include/mx/api/StaffData.h
index ac4f0a61b..e852f4831 100644
--- a/Sourcecode/include/mx/api/StaffData.h
+++ b/Sourcecode/include/mx/api/StaffData.h
@@ -58,7 +58,7 @@ namespace mx
         MXAPI_EQUALS_MEMBER( directions )
         if( !( voicesAreEqual( lhs.voices, rhs.voices ) ) )
         {
-            streamComparisonUnequalMessage( "StaffData", "voices" );
+            MX_SHOW_UNEQUAL( "StaffData", "voices" );
             return false;
         }
         MXAPI_EQUALS_END;
diff --git a/Sourcecode/private/mx/core/elements/KeyAttributes.cpp b/Sourcecode/private/mx/core/elements/KeyAttributes.cpp
index 74653620b..e67364904 100755
--- a/Sourcecode/private/mx/core/elements/KeyAttributes.cpp
+++ b/Sourcecode/private/mx/core/elements/KeyAttributes.cpp
@@ -33,7 +33,9 @@ namespace mx
         ,hasFontWeight( false )
         ,hasColor( false )
         ,hasPrintObject( false )
-        {}
+        {
+
+        }
 
 
         bool KeyAttributes::hasValues() const
diff --git a/Sourcecode/private/mx/impl/Converter.cpp b/Sourcecode/private/mx/impl/Converter.cpp
index 49d481cd3..ff78473c3 100644
--- a/Sourcecode/private/mx/impl/Converter.cpp
+++ b/Sourcecode/private/mx/impl/Converter.cpp
@@ -1804,6 +1804,34 @@ namespace mx
         {
             return findApiItem( kindMap, api::ChordKind::unspecified, value );
         }
-        
+
+        mx::core::DecimalType Converter::convertToAlter( int semitones, double cents )
+        {
+            double alter = 0.0;
+            if( semitones != 0 || cents != 0.0 )
+            {
+                double microtones = 0.0;
+                if( cents != 0.0 ) {
+                    microtones = cents / 100.0;
+                }
+                alter = semitones + microtones;
+            }
+            return alter;
+        }
+
+        std::pair<int, double> Converter::convertToSemitonesAndCents( mx::core::DecimalType xmlAlter )
+        {
+            double myCents = 0.0;
+            const auto intAlter = static_cast<int>( xmlAlter );
+            const auto micro = xmlAlter - static_cast<mx::core::DecimalType> ( intAlter );
+            const auto microDistance = std::abs( micro );
+            if( microDistance >= 0.000000000001 )
+            {
+                const auto theCents = micro * 100.0;
+                const auto theNarrowCents = static_cast<decltype(mx::api::PitchData::cents)>( theCents );
+                myCents = theNarrowCents;
+            }
+            return std::make_pair( intAlter, myCents );
+        }
     }
 }
diff --git a/Sourcecode/private/mx/impl/Converter.h b/Sourcecode/private/mx/impl/Converter.h
index 28471d0d1..5325f482a 100644
--- a/Sourcecode/private/mx/impl/Converter.h
+++ b/Sourcecode/private/mx/impl/Converter.h
@@ -15,6 +15,7 @@
 #include "mx/core/elements/OrnamentsChoice.h"
 #include "mx/core/elements/TechnicalChoice.h"
 #include "mx/core/Enums.h"
+#include "mx/core/Decimals.h"
 
 #include <map>
 
@@ -25,6 +26,8 @@ namespace mx
         class Converter
         {
         public:
+            // TODO - all of these functions should be static
+
             core::StepEnum convert( api::Step value ) const;
             api::Step convert( core::StepEnum value ) const;
             
@@ -114,7 +117,10 @@ namespace mx
 
             core::KindValue convert( api::ChordKind value ) const;
             api::ChordKind convert( core::KindValue value ) const;
-            
+
+            static mx::core::DecimalType convertToAlter( int semitones, double cents );
+            static std::pair<int, double> convertToSemitonesAndCents( mx::core::DecimalType alter );
+
             const static std::map<core::StepEnum, api::Step> stepMap;
             const static std::map<core::NoteTypeValue, api::DurationName> durationMap;
             const static std::map<core::NoteheadValue, api::Notehead> noteheadMap;
diff --git a/Sourcecode/private/mx/impl/MeasureReader.cpp b/Sourcecode/private/mx/impl/MeasureReader.cpp
index dc9e3fab3..bc6941faf 100644
--- a/Sourcecode/private/mx/impl/MeasureReader.cpp
+++ b/Sourcecode/private/mx/impl/MeasureReader.cpp
@@ -454,7 +454,30 @@ namespace mx
 
                 if( keyType == core::KeyChoice::Choice::nonTraditionalKey )
                 {
-                    // TODO - support non-traditional keys
+                    api::KeyData keyData;
+                    const auto& nonTraditionalKeyParts = key.getKeyChoice()->getNonTraditionalKeySet();
+                    for( const auto& nonTraditionalKeyPart : nonTraditionalKeyParts )
+                    {
+                        api::KeyComponent keyComponent{};
+
+                        if( nonTraditionalKeyPart->getHasKeyAccidental() )
+                        {
+                            keyComponent.accidental = myConverter.convert(  nonTraditionalKeyPart->getKeyAccidental()->getValue() );
+                        }
+
+                        const auto alter = nonTraditionalKeyPart->getKeyAlter()->getValue().getValue();
+                        if( alter != 0.0 )
+                        {
+                            const auto semitoneAndCents = Converter::convertToSemitonesAndCents( alter );
+                            keyComponent.alter = semitoneAndCents.first;
+                            keyComponent.cents = semitoneAndCents.second;
+                        }
+
+                        keyComponent.step = myConverter.convert( nonTraditionalKeyPart->getKeyStep()->getValue() );
+                        keyData.nonTraditional.emplace_back( keyComponent );
+                    }
+
+                    myOutMeasureData.keys.emplace_back( std::move( keyData ) );
                     continue;
                 }
                 
diff --git a/Sourcecode/private/mx/impl/MeasureWriter.cpp b/Sourcecode/private/mx/impl/MeasureWriter.cpp
index c7f44602c..de3a9b5fd 100644
--- a/Sourcecode/private/mx/impl/MeasureWriter.cpp
+++ b/Sourcecode/private/mx/impl/MeasureWriter.cpp
@@ -240,7 +240,7 @@ namespace mx
             
             while( myMeasureKeysIter != myMeasureKeysEnd && myMeasureKeysIter->tickTimePosition == 0 )
             {
-                myPropertiesWriter->writeKey( -1, *myMeasureKeysIter );
+                myPropertiesWriter->writeKey( myMeasureKeysIter->staffIndex, *myMeasureKeysIter );
                 ++myMeasureKeysIter;
             }
         }
diff --git a/Sourcecode/private/mx/impl/NoteReader.cpp b/Sourcecode/private/mx/impl/NoteReader.cpp
index 4295ea35e..6151e2cb0 100644
--- a/Sourcecode/private/mx/impl/NoteReader.cpp
+++ b/Sourcecode/private/mx/impl/NoteReader.cpp
@@ -44,6 +44,7 @@
 
 #include <map>
 #include "mx/api/PitchData.h"
+#include "Converter.h"
 
 namespace mx
 {
@@ -214,16 +215,11 @@ namespace mx
                     const auto& pitch = *fullNoteTypeChoice.getPitch();
                     myStep = pitch.getStep()->getValue();
                     myOctave = pitch.getOctave()->getValue().getValue();
-                    const auto xmlAlter = pitch.getAlter()->getValue().getValue();
-                    const auto intAlter = static_cast<int>( xmlAlter );
-                    myAlter = intAlter;
-                    const auto micro = xmlAlter - static_cast<mx::core::DecimalType> ( intAlter );
-                    const auto microDistance = std::abs( micro );
-                    if( microDistance >= 0.000000000001 )
+                    if( pitch.getHasAlter() )
                     {
-                        const auto theCents = micro * 100.0;
-                        const auto theNarrowCents = static_cast<decltype(mx::api::PitchData::cents)>( theCents );
-                        myCents = theNarrowCents;
+                        const auto semitonesAndCents = mx::impl::Converter::convertToSemitonesAndCents( pitch.getAlter()->getValue().getValue() );
+                        myAlter = semitonesAndCents.first;
+                        myCents = semitonesAndCents.second;
                     }
                     break;
                 }
diff --git a/Sourcecode/private/mx/impl/NoteWriter.cpp b/Sourcecode/private/mx/impl/NoteWriter.cpp
index c0003bb39..4452b199f 100644
--- a/Sourcecode/private/mx/impl/NoteWriter.cpp
+++ b/Sourcecode/private/mx/impl/NoteWriter.cpp
@@ -370,13 +370,9 @@ namespace mx
                 myOutFullNoteTypeChoice->setChoice( core::FullNoteTypeChoice::Choice::pitch );
                 auto pitch = myOutFullNoteTypeChoice->getPitch();
                 pitch->getStep()->setValue( myConverter.convert( myNoteData.pitchData.step ) );
-                if( myNoteData.pitchData.alter != 0 )
+                if( myNoteData.pitchData.alter != 0 || myNoteData.pitchData.cents != 0.0 )
                 {
-                    core::DecimalType microtones = 0.0;
-                    if( myNoteData.pitchData.cents != 0.0 ) {
-                        microtones = static_cast<core::DecimalType>( myNoteData.pitchData.cents / 100.0 );
-                    }
-                    const auto alter = static_cast<core::DecimalType>( myNoteData.pitchData.alter ) + microtones;
+                    const auto alter = Converter::convertToAlter( myNoteData.pitchData.alter, myNoteData.pitchData.cents );
                     pitch->setHasAlter( true );
                     pitch->getAlter()->setValue( core::Semitones{ alter } );
                 }
@@ -398,8 +394,7 @@ namespace mx
                 myOutNote->getEditorialVoiceGroup()->setHasVoice( true );
                 myOutNote->getEditorialVoiceGroup()->getVoice()->setValue( core::XsString{ std::to_string( myCursor.voiceIndex + 1 ) } );
             }
-            // TODO - only show voice number if it is needed
-            // i.e. only show if != 0 or voiceCount > 1
+            // TODO - only show voice number if it is needed i.e. only show if != 0 or voiceCount > 1
         }
         
         
diff --git a/Sourcecode/private/mx/impl/PropertiesWriter.cpp b/Sourcecode/private/mx/impl/PropertiesWriter.cpp
index 55599debf..94611f366 100644
--- a/Sourcecode/private/mx/impl/PropertiesWriter.cpp
+++ b/Sourcecode/private/mx/impl/PropertiesWriter.cpp
@@ -2,6 +2,7 @@
 // Copyright (c) by Matthew James Briggs
 // Distributed under the MIT License
 
+#include "mx/core/Elements.h"
 #include "mx/impl/PropertiesWriter.h"
 #include "mx/core/elements/Properties.h"
 #include "mx/core/elements/Clef.h"
@@ -9,6 +10,7 @@
 #include "mx/core/elements/Divisions.h"
 #include "mx/core/elements/EditorialGroup.h"
 #include "mx/core/elements/Footnote.h"
+#include "mx/core/elements/KeyAccidental.h"
 #include "mx/core/elements/Instruments.h"
 #include "mx/core/elements/Key.h"
 #include "mx/core/elements/Level.h"
@@ -155,32 +157,70 @@ namespace mx
         
         void PropertiesWriter::writeKey( int staffIndex, const api::KeyData& inKeyData )
         {
-            // TODO - support non-traditional keys
             // TODO - support placement and other attributes
+
             auto key = core::makeKey();
-            
+
             if( staffIndex >= 0 )
             {
                 key->getAttributes()->hasNumber = true;
                 key->getAttributes()->number = core::StaffNumber{ staffIndex + 1 };
             }
-            
+
+            if( inKeyData.nonTraditional.empty() )
+            {
+                writeTraditionalKey( inKeyData, key );
+            }
+            else
+            {
+                writeNonTraditionalKey( inKeyData, key );
+            }
+
+            myProperties->addKey( key );
+        }
+
+        void PropertiesWriter::writeNonTraditionalKey( const api::KeyData& inKeyData, mx::core::KeyPtr& key )
+        {
+            Converter converter;
+            key->getKeyChoice()->setChoice( core::KeyChoice::Choice::nonTraditionalKey );
+            for( const auto& keyComponent : inKeyData.nonTraditional )
+            {
+                auto nt = core::makeNonTraditionalKey();
+                if( keyComponent.accidental != api::Accidental::none )
+                {
+                    nt->setHasKeyAccidental( true );
+                    const auto a = nt->getKeyAccidental();
+
+                    a->setValue( converter.convert( keyComponent.accidental ) );
+                }
+
+                const auto isUnknown = keyComponent.step == api::Step::unspecified; // || keyComponent.step == api::Step::count;
+                const auto step = isUnknown ? api::Step::c : keyComponent.step;
+                nt->getKeyStep()->setValue( converter.convert( step ) );
+
+                const auto alter = Converter::convertToAlter( keyComponent.alter, keyComponent.cents );
+                nt->getKeyAlter()->setValue( core::Semitones{ alter } );
+                key->getKeyChoice()->addNonTraditionalKey( nt );
+            }
+        }
+
+        void PropertiesWriter::writeTraditionalKey( const api::KeyData& inKeyData, mx::core::KeyPtr& key )
+        {
             key->getKeyChoice()->setChoice( core::KeyChoice::Choice::traditionalKey );
             auto traditionalKey = key->getKeyChoice()->getTraditionalKey();
             traditionalKey->getFifths()->setValue( core::FifthsValue{ inKeyData.fifths } );
-            
+
             if ( inKeyData.cancel != 0 )
             {
                 traditionalKey->setHasCancel( true );
                 traditionalKey->getCancel()->setValue( core::FifthsValue{ inKeyData.cancel } );
             }
-            
+
             if( inKeyData.mode == api::KeyMode::major || inKeyData.mode == api::KeyMode::minor )
             {
                 traditionalKey->setHasMode( true );
                 traditionalKey->getMode()->setValue( core::ModeValue{ inKeyData.mode == api::KeyMode::major ? core::ModeEnum::major : core::ModeEnum::minor } );
             }
-            myProperties->addKey( key );
         }
         
         
diff --git a/Sourcecode/private/mx/impl/PropertiesWriter.h b/Sourcecode/private/mx/impl/PropertiesWriter.h
index 89e3f3778..a835cbe11 100644
--- a/Sourcecode/private/mx/impl/PropertiesWriter.h
+++ b/Sourcecode/private/mx/impl/PropertiesWriter.h
@@ -17,6 +17,8 @@ namespace mx
         using PartwiseMeasurePtr = std::shared_ptr<PartwiseMeasure>;
         class Properties;
         using PropertiesPtr = std::shared_ptr<Properties>;
+        class Key;
+        using KeyPtr = std::shared_ptr<Key>;
 	}
 
     namespace impl
@@ -43,6 +45,8 @@ namespace mx
 
             void writeDivisions( int value );
             void writeKey( int staffIndex, const api::KeyData& inKeyData );
+            static void writeTraditionalKey( const api::KeyData& inKeyData, mx::core::KeyPtr& ioKey );
+            static void writeNonTraditionalKey( const api::KeyData& inKeyData, mx::core::KeyPtr& ioKey );
             void writeTime( const api::TimeSignatureData& value );
             void writeNumStaves( int value );
             void writeClef( int staffIndex, const api::ClefData& inClefData );
diff --git a/Sourcecode/private/mxtest/api/KeyDataTest.cpp b/Sourcecode/private/mxtest/api/KeyDataTest.cpp
new file mode 100644
index 000000000..12e4aa108
--- /dev/null
+++ b/Sourcecode/private/mxtest/api/KeyDataTest.cpp
@@ -0,0 +1,376 @@
+// MusicXML Class Library
+// Copyright (c) by Matthew James Briggs
+// Distributed under the MIT License
+
+#include <sstream>
+#include "mxtest/control/CompileControl.h"
+
+#ifdef MX_COMPILE_API_TESTS
+
+#include "cpul/cpulTestHarness.h"
+#include "mx/api/DocumentManager.h"
+#include "mx/core/Document.h"
+
+using namespace std;
+using namespace mx::api;
+//using namespace mxtest;
+
+namespace
+{
+    ScoreData putKeyInScore( KeyData key )
+    {
+        ScoreData score;
+        score.parts.push_back( PartData{} );
+        auto& part = score.parts.back();
+        part.measures.emplace_back( );
+        auto& measure = part.measures.back();
+        measure.keys.push_back( key );
+        return score;
+    }
+}
+
+TEST( EMajor, KeyData )
+{
+    KeyData key;
+    key.fifths = 4;
+    key.cancel = -1;
+    key.mode = KeyMode::major;
+    key.staffIndex = 0;
+
+    const auto original = putKeyInScore( key );
+    auto& docMgr = DocumentManager::getInstance();
+    const int originalId = docMgr.createFromScore( original );
+    const mx::core::DocumentPtr corePtr = docMgr.getDocument( originalId );
+    const auto coreScorePtr = corePtr->getScorePartwise();
+    const auto coreParts = coreScorePtr->getPartwisePartSet();
+    REQUIRE( 1 == coreParts.size() );
+    const auto corePart = coreParts.at( 0 );
+    const auto coreMeasures = corePart->getPartwiseMeasureSet();
+    REQUIRE( 1 == coreMeasures.size() );
+    const auto coreMeasure = coreMeasures.at( 0 );
+    const auto coreKeySet = coreMeasure->getMusicDataGroup()->getMusicDataChoiceSet().at( 0 )->getProperties()->getKeySet();
+    REQUIRE( 1 == coreKeySet.size() );
+    const auto coreKeyChoice = coreKeySet.at( 0 );
+    CHECK_EQUAL( mx::core::KeyChoice::Choice::traditionalKey, coreKeyChoice->getKeyChoice()->getChoice() );
+    const auto coreKey = coreKeyChoice->getKeyChoice()->getTraditionalKey();
+
+    // check if the staff number was written
+    CHECK( coreKeyChoice->getAttributes()->hasNumber )
+    CHECK_EQUAL( key.staffIndex, coreKeyChoice->getAttributes()->number.getValue() - 1 );
+
+    // check the mode
+    CHECK( coreKey->getHasMode() )
+    CHECK_EQUAL( mx::core::ModeEnum::major, coreKey->getMode()->getValue().getValue() );
+
+    // check the cancel
+    CHECK( coreKey->getHasCancel() )
+    CHECK_EQUAL( -1, coreKey->getCancel()->getValue().getValue() );
+
+    // check the fifths
+    CHECK_EQUAL( 4, coreKey->getFifths()->getValue().getValue() );
+
+    // serialize and deserialize
+    std::stringstream xml;
+    docMgr.writeToStream( originalId, xml );
+    docMgr.destroyDocument( originalId );
+    std::istringstream iss{ xml.str() };
+    const auto deserializedId = docMgr.createFromStream( iss );
+    const auto deserializedScore = docMgr.getData( deserializedId );
+    docMgr.destroyDocument( deserializedId );
+    const auto& deserializedKeys = deserializedScore.parts.at( 0 ).measures.at( 0 ).keys;
+    CHECK_EQUAL( 1, deserializedKeys.size() )
+    const auto deserializedKey = deserializedKeys.at( 0 );
+
+    CHECK_EQUAL( key.staffIndex, deserializedKey.staffIndex );
+    CHECK_EQUAL( key.cancel, deserializedKey.cancel );
+    CHECK_EQUAL( key.fifths, deserializedKey.fifths );
+    CHECK_EQUAL( key.mode , deserializedKey.mode );
+    CHECK_EQUAL( 0, deserializedKey.tickTimePosition );
+    CHECK( deserializedKey.nonTraditional.empty() );
+}
+
+TEST( AbMinor, KeyData )
+{
+    KeyData key;
+    key.fifths = -7;
+    key.cancel = 0;
+    key.mode = KeyMode::minor;
+    key.staffIndex = -10;
+
+    const auto original = putKeyInScore( key );
+    auto& docMgr = DocumentManager::getInstance();
+    const int originalId = docMgr.createFromScore( original );
+    const mx::core::DocumentPtr corePtr = docMgr.getDocument( originalId );
+    const auto coreScorePtr = corePtr->getScorePartwise();
+    const auto coreParts = coreScorePtr->getPartwisePartSet();
+    REQUIRE( 1 == coreParts.size() );
+    const auto corePart = coreParts.at( 0 );
+    const auto coreMeasures = corePart->getPartwiseMeasureSet();
+    REQUIRE( 1 == coreMeasures.size() );
+    const auto coreMeasure = coreMeasures.at( 0 );
+    const auto coreKeySet = coreMeasure->getMusicDataGroup()->getMusicDataChoiceSet().at( 0 )->getProperties()->getKeySet();
+    REQUIRE( 1 == coreKeySet.size() );
+    const auto coreKeyChoice = coreKeySet.at( 0 );
+    CHECK_EQUAL( mx::core::KeyChoice::Choice::traditionalKey, coreKeyChoice->getKeyChoice()->getChoice() );
+    const auto coreKey = coreKeyChoice->getKeyChoice()->getTraditionalKey();
+
+    // check if the staff number was written
+    CHECK( !coreKeyChoice->getAttributes()->hasNumber )
+
+    // check the mode
+    CHECK( coreKey->getHasMode() )
+    CHECK_EQUAL( mx::core::ModeEnum::minor, coreKey->getMode()->getValue().getValue() );
+
+    // check the cancel
+    CHECK( !coreKey->getHasCancel() )
+    CHECK_EQUAL( 0, coreKey->getCancel()->getValue().getValue() );
+
+    // check the fifths
+    CHECK_EQUAL( key.fifths, coreKey->getFifths()->getValue().getValue() );
+
+    // serialize and deserialize
+    std::stringstream xml;
+    docMgr.writeToStream( originalId, xml );
+    docMgr.destroyDocument( originalId );
+    std::istringstream iss{ xml.str() };
+    const auto deserializedId = docMgr.createFromStream( iss );
+    const auto deserializedScore = docMgr.getData( deserializedId );
+    docMgr.destroyDocument( deserializedId );
+    const auto& deserializedKeys = deserializedScore.parts.at( 0 ).measures.at( 0 ).keys;
+    CHECK_EQUAL( 1, deserializedKeys.size() )
+    const auto deserializedKey = deserializedKeys.at( 0 );
+
+    CHECK_EQUAL( -1, deserializedKey.staffIndex );
+    CHECK_EQUAL( key.cancel, deserializedKey.cancel );
+    CHECK_EQUAL( key.fifths, deserializedKey.fifths );
+    CHECK_EQUAL( key.mode , deserializedKey.mode );
+    CHECK_EQUAL( 0, deserializedKey.tickTimePosition );
+    CHECK( deserializedKey.nonTraditional.empty() );
+}
+
+TEST( NonTraditional1, KeyData )
+{
+    KeyData key;
+    key.fifths = 1; // should be ignored
+    key.cancel = 2;
+    key.mode = KeyMode::minor; // should be ignored
+    key.staffIndex = -1;
+    KeyComponent cSharp{ Step::c, 1, 0.0, Accidental::sharp };
+    KeyComponent dQuarterFlat{ Step::d, 0, -50.0, Accidental::quarterFlat };
+    key.nonTraditional.push_back( cSharp );
+    key.nonTraditional.push_back( dQuarterFlat );
+
+    const auto original = putKeyInScore( key );
+    auto& docMgr = DocumentManager::getInstance();
+    const int originalId = docMgr.createFromScore( original );
+    const mx::core::DocumentPtr corePtr = docMgr.getDocument( originalId );
+    const auto coreScorePtr = corePtr->getScorePartwise();
+    const auto coreParts = coreScorePtr->getPartwisePartSet();
+    REQUIRE( 1 == coreParts.size() );
+    const auto corePart = coreParts.at( 0 );
+    const auto coreMeasures = corePart->getPartwiseMeasureSet();
+    REQUIRE( 1 == coreMeasures.size() );
+    const auto coreMeasure = coreMeasures.at( 0 );
+    const auto coreKeySet = coreMeasure->getMusicDataGroup()->getMusicDataChoiceSet().at( 0 )->getProperties()->getKeySet();
+    REQUIRE( 1 == coreKeySet.size() );
+    const auto coreKeyChoice = coreKeySet.at( 0 );
+    CHECK_EQUAL( mx::core::KeyChoice::Choice::nonTraditionalKey, coreKeyChoice->getKeyChoice()->getChoice() );
+    const auto coreKeyComponents = coreKeyChoice->getKeyChoice()->getNonTraditionalKeySet();
+    REQUIRE( 2 == coreKeyComponents.size() );
+
+    // check if the staff number was written
+    CHECK( !coreKeyChoice->getAttributes()->hasNumber )
+
+    // check a key component
+    size_t keyComponentIndex = 0;
+    auto keyComponent = coreKeyComponents.at( keyComponentIndex );
+    CHECK_EQUAL( mx::core::StepEnum::c, keyComponent->getKeyStep()->getValue() );
+    CHECK_DOUBLES_EQUAL( 1.0, keyComponent->getKeyAlter()->getValue().getValue(), 0.0001 )
+    CHECK( keyComponent->getHasKeyAccidental() );
+    CHECK_EQUAL( mx::core::AccidentalValue::sharp, keyComponent->getKeyAccidental()->getValue() );
+
+    // check a key component
+    keyComponentIndex = 1;
+    keyComponent = coreKeyComponents.at( keyComponentIndex );
+    CHECK_EQUAL( mx::core::StepEnum::d, keyComponent->getKeyStep()->getValue() );
+    CHECK_DOUBLES_EQUAL( -0.50, keyComponent->getKeyAlter()->getValue().getValue(), 0.0001 )
+    CHECK( keyComponent->getHasKeyAccidental() );
+    CHECK_EQUAL( mx::core::AccidentalValue::quarterFlat, keyComponent->getKeyAccidental()->getValue() );
+
+    // serialize and deserialize
+    std::stringstream xml;
+    docMgr.writeToStream( originalId, xml );
+    docMgr.destroyDocument( originalId );
+    std::istringstream iss{ xml.str() };
+    const auto deserializedId = docMgr.createFromStream( iss );
+    const auto deserializedScore = docMgr.getData( deserializedId );
+    docMgr.destroyDocument( deserializedId );
+    const auto& deserializedKeys = deserializedScore.parts.at( 0 ).measures.at( 0 ).keys;
+    CHECK_EQUAL( 1, deserializedKeys.size() )
+    const auto deserializedKey = deserializedKeys.at( 0 );
+
+    CHECK_EQUAL( -1, deserializedKey.staffIndex );
+    CHECK_EQUAL( 0, deserializedKey.cancel ); // Non-Traditional Keys Cannot have a Cancel Component
+    CHECK_EQUAL( 0, deserializedKey.fifths );
+    CHECK_EQUAL( KeyMode::unspecified, deserializedKey.mode );
+    CHECK_EQUAL( 0, deserializedKey.tickTimePosition );
+    CHECK_EQUAL( 2, deserializedKey.nonTraditional.size() );
+
+    CHECK_EQUAL( cSharp, deserializedKey.nonTraditional.at( 0 ) );
+    CHECK_EQUAL( dQuarterFlat, deserializedKey.nonTraditional.at( 1 ) );
+}
+
+TEST( KeyDataEquality_change_fifths, KeyData )
+{
+    KeyData key1;
+    key1.fifths = 4;
+    key1.cancel = -1;
+    key1.mode = KeyMode::major;
+    key1.staffIndex = 0;
+    key1.nonTraditional.push_back( KeyComponent{ Step::c, 1, 0.0, Accidental::sharp } );
+    key1.nonTraditional.push_back( KeyComponent{ Step::d, 0, -50.0, Accidental::quarterFlat } );
+    key1.tickTimePosition = 13;
+    auto key2 = key1;
+    CHECK( key1 == key2 );
+    CHECK( !( key1 != key2 ) );
+
+    // change one thing
+    key1.fifths += 1;
+    CHECK( key1 != key2 );
+    CHECK( !( key1 == key2 ) );
+
+}
+
+TEST( KeyDataEquality_change_cancel, KeyData )
+{
+    KeyData key1;
+    key1.fifths = 4;
+    key1.cancel = -1;
+    key1.mode = KeyMode::major;
+    key1.staffIndex = 0;
+    key1.nonTraditional.push_back( KeyComponent{ Step::c, 1, 0.0, Accidental::sharp } );
+    key1.nonTraditional.push_back( KeyComponent{ Step::d, 0, -50.0, Accidental::quarterFlat } );
+    key1.tickTimePosition = 13;
+    auto key2 = key1;
+    CHECK( key1 == key2 );
+    CHECK( !( key1 != key2 ) );
+
+    // change one thing
+    key1.cancel += 1;
+    CHECK( key1 != key2 );
+    CHECK( !( key1 == key2 ) );
+
+}
+
+TEST( KeyDataEquality_change_mode, KeyData )
+{
+    KeyData key1;
+    key1.fifths = 4;
+    key1.cancel = -1;
+    key1.mode = KeyMode::major;
+    key1.staffIndex = 0;
+    key1.nonTraditional.push_back( KeyComponent{ Step::c, 1, 0.0, Accidental::sharp } );
+    key1.nonTraditional.push_back( KeyComponent{ Step::d, 0, -50.0, Accidental::quarterFlat } );
+    key1.tickTimePosition = 13;
+    auto key2 = key1;
+    CHECK( key1 == key2 );
+    CHECK( !( key1 != key2 ) );
+
+    // change one thing
+    key1.mode = KeyMode::unspecified;
+    CHECK( key1 != key2 );
+    CHECK( !( key1 == key2 ) );
+}
+
+TEST( KeyDataEquality_change_staffIndex, KeyData )
+{
+    KeyData key1;
+    key1.fifths = 4;
+    key1.cancel = -1;
+    key1.mode = KeyMode::major;
+    key1.staffIndex = 0;
+    key1.nonTraditional.push_back( KeyComponent{ Step::c, 1, 0.0, Accidental::sharp } );
+    key1.nonTraditional.push_back( KeyComponent{ Step::d, 0, -50.0, Accidental::quarterFlat } );
+    key1.tickTimePosition = 13;
+    auto key2 = key1;
+    CHECK( key1 == key2 );
+    CHECK( !( key1 != key2 ) );
+
+    // change one thing
+    key1.staffIndex += 1;
+    CHECK( key1 != key2 );
+    CHECK( !( key1 == key2 ) );
+}
+
+TEST( KeyDataEquality_change_nonTraditionalKey, KeyData )
+{
+    KeyData key1;
+    key1.fifths = 4;
+    key1.cancel = -1;
+    key1.mode = KeyMode::major;
+    key1.staffIndex = 0;
+    key1.nonTraditional.push_back( KeyComponent{ Step::c, 1, 0.0, Accidental::sharp } );
+    key1.nonTraditional.push_back( KeyComponent{ Step::d, 0, -50.0, Accidental::quarterFlat } );
+    key1.tickTimePosition = 13;
+    auto key2 = key1;
+    CHECK( key1 == key2 );
+    CHECK( !( key1 != key2 ) );
+
+    // change one thing
+    key1.nonTraditional.at( 0 ).cents += 0.01;
+    CHECK( key1 != key2 );
+    CHECK( !( key1 == key2 ) );
+}
+
+TEST( KeyComponentEquality_change_alter, KeyComponent )
+{
+    KeyComponent kc1;
+    kc1.cents = 1.0;
+    kc1.alter = 2;
+    kc1.accidental = Accidental::sori;
+    kc1.step = Step::d;
+    auto kc2 = kc1;
+    CHECK( kc1 == kc2 );
+    CHECK( !( kc1 != kc2 ) );
+
+    // change one thing
+    kc1.alter += 1;
+    CHECK( kc1 != kc2 );
+    CHECK( !( kc1 == kc2 ) );
+}
+
+TEST( KeyComponentEquality_change_accidental, KeyComponent )
+{
+    KeyComponent kc1;
+    kc1.cents = 1.0;
+    kc1.alter = 2;
+    kc1.accidental = Accidental::sori;
+    kc1.step = Step::d;
+    auto kc2 = kc1;
+    CHECK( kc1 == kc2 );
+    CHECK( !( kc1 != kc2 ) );
+
+    // change one thing
+    kc1.accidental = Accidental::flat4;
+    CHECK( kc1 != kc2 );
+    CHECK( !( kc1 == kc2 ) );
+}
+
+TEST( KeyComponentEquality_change_step, KeyComponent )
+{
+    KeyComponent kc1;
+    kc1.cents = 1.0;
+    kc1.alter = 2;
+    kc1.accidental = Accidental::sori;
+    kc1.step = Step::d;
+    auto kc2 = kc1;
+    CHECK( kc1 == kc2 );
+    CHECK( !( kc1 != kc2 ) );
+
+    // change one thing
+    kc1.step = Step::e;
+    CHECK( kc1 != kc2 );
+    CHECK( !( kc1 == kc2 ) );
+}
+
+#endif
\ No newline at end of file