CharacterController on Moving Surface

See Question 694 for several solutions.

Your solution work but it's quite illisible... here is my solution in C# my CharacterController is in multiple modules so I will just expose the code for my module PlayerGround

 [System.Serializable]
 public class PlayerGround : PlayerAttribute {
 
     private bool    m_grounded;
     private bool    m_prevGrounded;
     private Vector3 m_groundNormal;
 
     public bool    Grounded     { get { return m_grounded;     } }
     public bool    PrevGrounded { get { return m_prevGrounded; } }
     public Vector3 GroundNormal { get { return m_groundNormal; } }
 
     // attributes to check the platform
     private Transform m_platform;
 
     private Vector3 m_globalPoint;
     private Vector3 m_localPoint;
 
     private Quaternion m_globalRotation;
     private Quaternion m_localRotation;
 
     /* INIT METHOD */
     //public override void Init(PlayerController controller) { base.Init(controller); }
 
     /* UPDATE METHOD */
     public override void Update() {
         // we update the state of the player
         GroundCheck();
 
         //Vector3 lastVelocity = Vector3.zero;
 
         // if we are on a platform
         if ( m_platform != null ) {
             // we calculate the movement of the platform since the last update
             Vector3 newGlobalPoint = m_platform.TransformPoint(m_localPoint);
             Vector3 moveDistance = newGlobalPoint - m_globalPoint;
             // we apply the movement to the player
             m_ctrl.transform.position += moveDistance;
 
             // we calculate the rotation of the platform since the last update
             Quaternion newGlobalRotation = m_platform.rotation * m_localRotation;
             Quaternion rotationDiff = newGlobalRotation * Quaternion.Inverse(m_globalRotation);
             // we apply the rotation to the player
             m_ctrl.transform.rotation = rotationDiff * m_ctrl.transform.rotation;
             // Quaternion multiplication is not commutative !
         }
     }
 
     // allow to keep track of the position and rotation of the platform
     public void UpdatePlatform() {
         if ( m_platform != null ) {
             // we recover the position of the platform for the next update
             m_globalPoint = m_ctrl.transform.position;
             m_localPoint = m_platform.InverseTransformPoint(m_ctrl.transform.position);
             // we recover the rotation of the platform for the next update
             m_globalRotation = m_ctrl.transform.rotation;
             m_localRotation = Quaternion.Inverse(m_platform.rotation) * m_ctrl.transform.rotation;
         }
     }
 
     // we check if the player is on the ground
     public void GroundCheck() {
         RaycastHit hitInfo;
         m_prevGrounded = m_grounded;
         // if the player has a ground beneath his feet
         if (Physics.SphereCast(
             m_ctrl.transform.position,
             m_ctrl.Collider.radius,
             Vector3.down,
             out hitInfo,
             ((m_ctrl.Collider.height / 2f) - m_ctrl.Collider.radius) + 0.01f)
         ) {
             // he is grounded
             m_grounded = true;
             m_groundNormal = hitInfo.normal;
             
             // we check if we changed of platform
             bool platformChange = m_platform != hitInfo.transform;
             // we recover the platform on which the player is standing
             m_platform = hitInfo.transform;
             // if we just changed of platform
             if ( platformChange ) {
                 // we update the position of the platform once
                 UpdatePlatform();
             }
         } else {
             // he is not grounded
             m_grounded = false;
             m_groundNormal = Vector3.up;
             // the player is not on a platform
             m_platform = null;
         }
         // if the player just leave the ground without jumping
         if (!m_prevGrounded && m_grounded && m_ctrl.Move.Jumping) {
             // he is not jumping
             m_ctrl.Move.Jumping = false;
         }
     }
 
     // we fix the player to the ground
     public void StickToGround() {
         // if the ground under the feet of the player is not too much steep
         if (Mathf.Abs(Vector3.Angle(m_groundNormal, Vector3.up)) < 85f) {
             // we stick the player to the ground
             m_ctrl.Body.velocity = Vector3.ProjectOnPlane(m_ctrl.Body.velocity, m_groundNormal);
         }
     }
 }

Then in my the update function of my PlayerController, I call PlayerGround.Update(); then I move the character based on player's inputs then I call PlayerGround.UpdatePlatform();

A real naive yet effective and convincing approach is to re-parent the transform of your character to the platform below you using a simple raycast firing straight down. This works, but may need optimizations.